Merge commit '5671d014bc1792a116d374792f8a6cfba2e6f512' into merge-vulkan-1.1.121ndk-r21endk-r21dndk-r21cndk-r21bndk-r21-rc1ndk-r21-beta2ndk-r21-beta1ndk-r21ndk-sysroot-r21ndk-release-r21

Change-Id: I7fa8057a997c691b93f92d3e92295b634ad17134

26 files changed, 22540 insertions, 8977 deletions

diff --git a/BUILD.md b/BUILD.md
index 948e2bc..a94f8e7 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -78,7 +78,7 @@ directories and place them in any location.
     - [2017](https://www.visualstudio.com/vs/downloads/)
   - The Community Edition of each of the above versions is sufficient, as
     well as any more capable edition.
-- CMake: Continuous integration tools use [CMake 3.12.2](https://github.com/Kitware/CMake/releases/tag/v3.12.2) for Windows
+- [CMake 3.10.2](https://cmake.org/files/v3.10/cmake-3.10.2-win64-x64.zip) is recommended.
   - Use the installer option to add CMake to the system PATH
 - Git Client Support
   - [Git for Windows](http://git-scm.com/download/win) is a popular solution
@@ -189,7 +189,7 @@ Build the `uninstall` target to remove the files from the install directory.
 There are no specific Linux distribution or compiler version requirements for
 building this repository. The required tools are
 
-- CMake: Continuous integration tools use [CMake 3.12.4](https://github.com/Kitware/CMake/releases/tag/v3.12.4) for Linux
+- [CMake 3.10.2](https://cmake.org/files/v3.10/cmake-3.10.2-Linux-x86_64.tar.gz) is recommended.
 - git
 
 ### Linux Build
@@ -267,4 +267,5 @@ or
 ## Building on MacOS
 
 The instructions for building this repository on MacOS are similar to those for Linux.
-- CMake: Continuous integration tools use [CMake 3.11.3](https://github.com/Kitware/CMake/releases/tag/v3.11.3) for MacOS
+
+[CMake 3.10.2](https://cmake.org/files/v3.10/cmake-3.10.2-Darwin-x86_64.tar.gz) is recommended.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2640891..fc96c5e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,7 @@
 # CMake project initialization ---------------------------------------------------------------------------------------------------
 # This section contains pre-project() initialization, and ends with the project() command.
 
-cmake_minimum_required(VERSION 2.8.11)
+cmake_minimum_required(VERSION 3.10.2)
 
 # NONE = this project has no language toolchain requirement.
 project(Vulkan-Headers NONE)
diff --git a/README.md b/README.md
index 685e712..4687289 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,11 @@ Vulkan header files and API registry
 The contents of this repository are largely obtained from other repositories and are
 collected, coordinated, and curated here.
 
+Do not propose pull requests to this repository which modify any files under
+include/vulkan/ or registry/. All such files are generated from the
+Vulkan-Docs repository and, in the case of include/vulkan/vulkan.hpp, the
+Vulkan-Hpp repository. Any changes must be made in those repositories.
+
 The projects for these repositories are:
 
 - [KhronosGroup/Vulkan-Docs](https://github.com/KhronosGroup/Vulkan-Docs)
@@ -19,8 +24,12 @@ asking questions, or opening issues.
 
 ## Version Tagging Scheme
 
-Updates to the `Vulkan-Headers` repository which correspond to a new Vulkan specification release are tagged using the following format: `v<`_`version`_`>` (e.g., `v1.1.96`).
+Updates to the `Vulkan-Headers` repository which correspond to a new Vulkan
+specification release are tagged using the following format:
+`v<`_`version`_`>` (e.g., `v1.1.96`).
 
-**Note**: Marked version releases have undergone thorough testing but do not imply the same quality level as SDK tags. SDK tags follow the `sdk-<`_`version`_`>.<`_`patch`_`>` format (e.g., `sdk-1.1.92.0`).
+**Note**: Marked version releases have undergone thorough testing but do not
+imply the same quality level as SDK tags. SDK tags follow the
+`sdk-<`_`version`_`>.<`_`patch`_`>` format (e.g., `sdk-1.1.92.0`).
 
 This scheme was adopted following the 1.1.96 Vulkan specification release.
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index e1c079d..ee74848 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -56,7 +56,7 @@
 # define VULKAN_HPP_ASSERT   assert
 #endif
 
-static_assert( VK_HEADER_VERSION ==  114 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION ==  121 , "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
@@ -100,7 +100,7 @@ static_assert( VK_HEADER_VERSION ==  114 , "Wrong VK_HEADER_VERSION!" );
 #endif
 
 #if !defined(VULKAN_HPP_INLINE)
-# if defined(__clang___)
+# if defined(__clang__)
 #  if __has_attribute(always_inline)
 #   define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
 #  else
@@ -123,8 +123,10 @@ static_assert( VK_HEADER_VERSION ==  114 , "Wrong VK_HEADER_VERSION!" );
 
 #if defined(_MSC_VER) && (_MSC_VER <= 1800)
 # define VULKAN_HPP_CONSTEXPR
+# define VULKAN_HPP_CONST_OR_CONSTEXPR  const
 #else
 # define VULKAN_HPP_CONSTEXPR constexpr
+# define VULKAN_HPP_CONST_OR_CONSTEXPR  constexpr
 #endif
 
 #if !defined(VULKAN_HPP_NAMESPACE)
@@ -1013,6 +1015,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
     }
 
+    void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const
+    {
+      return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
+    }
+
     void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const
     {
       return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
@@ -1749,6 +1756,21 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
     }
 
+    VkResult vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations ) const
+    {
+      return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
+    }
+
+    VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties ) const
+    {
+      return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
+    }
+
+    VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics ) const
+    {
+      return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
+    }
+
     VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags ) const
     {
       return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
@@ -3401,7 +3423,8 @@ namespace VULKAN_HPP_NAMESPACE
     eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
     eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
     eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
-    eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV
+    eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV,
+    eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( DynamicState value )
@@ -3423,6 +3446,7 @@ namespace VULKAN_HPP_NAMESPACE
       case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV";
       case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV";
       case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV";
+      case DynamicState::eLineStippleEXT : return "LineStippleEXT";
       default: return "invalid";
     }
   }
@@ -3675,6 +3699,20 @@ namespace VULKAN_HPP_NAMESPACE
     ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
     ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
     ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
+    eAstc4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT,
+    eAstc5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT,
+    eAstc5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT,
+    eAstc6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT,
+    eAstc6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT,
+    eAstc8x5SfloatBlockEXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT,
+    eAstc8x6SfloatBlockEXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT,
+    eAstc8x8SfloatBlockEXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT,
+    eAstc10x5SfloatBlockEXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT,
+    eAstc10x6SfloatBlockEXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT,
+    eAstc10x8SfloatBlockEXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT,
+    eAstc10x10SfloatBlockEXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT,
+    eAstc12x10SfloatBlockEXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT,
+    eAstc12x12SfloatBlockEXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT,
     eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
     eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
     eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
@@ -3942,6 +3980,20 @@ namespace VULKAN_HPP_NAMESPACE
       case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG";
       case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG";
       case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG";
+      case Format::eAstc4x4SfloatBlockEXT : return "Astc4x4SfloatBlockEXT";
+      case Format::eAstc5x4SfloatBlockEXT : return "Astc5x4SfloatBlockEXT";
+      case Format::eAstc5x5SfloatBlockEXT : return "Astc5x5SfloatBlockEXT";
+      case Format::eAstc6x5SfloatBlockEXT : return "Astc6x5SfloatBlockEXT";
+      case Format::eAstc6x6SfloatBlockEXT : return "Astc6x6SfloatBlockEXT";
+      case Format::eAstc8x5SfloatBlockEXT : return "Astc8x5SfloatBlockEXT";
+      case Format::eAstc8x6SfloatBlockEXT : return "Astc8x6SfloatBlockEXT";
+      case Format::eAstc8x8SfloatBlockEXT : return "Astc8x8SfloatBlockEXT";
+      case Format::eAstc10x5SfloatBlockEXT : return "Astc10x5SfloatBlockEXT";
+      case Format::eAstc10x6SfloatBlockEXT : return "Astc10x6SfloatBlockEXT";
+      case Format::eAstc10x8SfloatBlockEXT : return "Astc10x8SfloatBlockEXT";
+      case Format::eAstc10x10SfloatBlockEXT : return "Astc10x10SfloatBlockEXT";
+      case Format::eAstc12x10SfloatBlockEXT : return "Astc12x10SfloatBlockEXT";
+      case Format::eAstc12x12SfloatBlockEXT : return "Astc12x12SfloatBlockEXT";
       default: return "invalid";
     }
   }
@@ -4110,7 +4162,8 @@ namespace VULKAN_HPP_NAMESPACE
   {
     eUint16 = VK_INDEX_TYPE_UINT16,
     eUint32 = VK_INDEX_TYPE_UINT32,
-    eNoneNV = VK_INDEX_TYPE_NONE_NV
+    eNoneNV = VK_INDEX_TYPE_NONE_NV,
+    eUint8EXT = VK_INDEX_TYPE_UINT8_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( IndexType value )
@@ -4120,6 +4173,7 @@ namespace VULKAN_HPP_NAMESPACE
       case IndexType::eUint16 : return "Uint16";
       case IndexType::eUint32 : return "Uint32";
       case IndexType::eNoneNV : return "NoneNV";
+      case IndexType::eUint8EXT : return "Uint8EXT";
       default: return "invalid";
     }
   }
@@ -4166,6 +4220,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class LineRasterizationModeEXT
+  {
+    eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
+    eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT,
+    eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT,
+    eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeEXT value )
+  {
+    switch ( value )
+    {
+      case LineRasterizationModeEXT::eDefault : return "Default";
+      case LineRasterizationModeEXT::eRectangular : return "Rectangular";
+      case LineRasterizationModeEXT::eBresenham : return "Bresenham";
+      case LineRasterizationModeEXT::eRectangularSmooth : return "RectangularSmooth";
+      default: return "invalid";
+    }
+  }
+
   enum class LogicOp
   {
     eClear = VK_LOGIC_OP_CLEAR,
@@ -4464,6 +4538,26 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class PipelineExecutableStatisticFormatKHR
+  {
+    eBool32 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
+    eInt64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR,
+    eUint64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR,
+    eFloat64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineExecutableStatisticFormatKHR value )
+  {
+    switch ( value )
+    {
+      case PipelineExecutableStatisticFormatKHR::eBool32 : return "Bool32";
+      case PipelineExecutableStatisticFormatKHR::eInt64 : return "Int64";
+      case PipelineExecutableStatisticFormatKHR::eUint64 : return "Uint64";
+      case PipelineExecutableStatisticFormatKHR::eFloat64 : return "Float64";
+      default: return "invalid";
+    }
+  }
+
   enum class PointClippingBehavior
   {
     eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
@@ -4736,7 +4830,8 @@ namespace VULKAN_HPP_NAMESPACE
     eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
     eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
     eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-    eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
+    eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
+    eMirrorClampToEdgeKHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR
   };
 
   VULKAN_HPP_INLINE std::string to_string( SamplerAddressMode value )
@@ -4851,6 +4946,24 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class ShaderFloatControlsIndependenceKHR
+  {
+    e32BitOnly = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR,
+    eAll = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR,
+    eNone = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderFloatControlsIndependenceKHR value )
+  {
+    switch ( value )
+    {
+      case ShaderFloatControlsIndependenceKHR::e32BitOnly : return "32BitOnly";
+      case ShaderFloatControlsIndependenceKHR::eAll : return "All";
+      case ShaderFloatControlsIndependenceKHR::eNone : return "None";
+      default: return "invalid";
+    }
+  }
+
   enum class ShaderInfoTypeAMD
   {
     eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
@@ -5103,6 +5216,7 @@ namespace VULKAN_HPP_NAMESPACE
     eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
     eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,
     eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN,
+    ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT,
     eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
     ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
     eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
@@ -5123,7 +5237,7 @@ namespace VULKAN_HPP_NAMESPACE
     eCommandBufferInheritanceConditionalRenderingInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
     ePhysicalDeviceConditionalRenderingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
     eConditionalRenderingBeginInfoEXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
-    ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
+    ePhysicalDeviceShaderFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR,
     ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
     eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX,
     eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX,
@@ -5242,6 +5356,7 @@ namespace VULKAN_HPP_NAMESPACE
     eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
     ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
     ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR,
+    ePipelineCompilerControlCreateInfoAMD = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
     eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT,
     ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
     eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
@@ -5263,7 +5378,7 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
     eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV,
     eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
-    ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL,
+    ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
     eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL,
     eInitializePerformanceApiInfoINTEL = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL,
     ePerformanceMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL,
@@ -5280,6 +5395,11 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
     eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
     ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT,
+    ePhysicalDeviceSubgroupSizeControlPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT,
+    ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
+    ePhysicalDeviceSubgroupSizeControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT,
+    ePhysicalDeviceShaderCoreProperties2AMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
+    ePhysicalDeviceCoherentMemoryFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
     ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
     ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
     eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
@@ -5303,7 +5423,17 @@ namespace VULKAN_HPP_NAMESPACE
     eSurfaceCapabilitiesFullScreenExclusiveEXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
     eSurfaceFullScreenExclusiveWin32InfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
     eHeadlessSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT,
+    ePhysicalDeviceLineRasterizationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
+    ePipelineRasterizationLineStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
+    ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
     ePhysicalDeviceHostQueryResetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT,
+    ePhysicalDeviceIndexTypeUint8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
+    ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
+    ePipelineInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR,
+    ePipelineExecutablePropertiesKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR,
+    ePipelineExecutableInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR,
+    ePipelineExecutableStatisticKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR,
+    ePipelineExecutableInternalRepresentationKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
     ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT,
     ePhysicalDeviceTexelBufferAlignmentFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
     ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT,
@@ -5342,6 +5472,7 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
     eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
     eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
+    ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
     ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,
     eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
     ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
@@ -5529,6 +5660,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV : return "Win32KeyedMutexAcquireReleaseInfoNV";
       case StructureType::eValidationFlagsEXT : return "ValidationFlagsEXT";
       case StructureType::eViSurfaceCreateInfoNN : return "ViSurfaceCreateInfoNN";
+      case StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT : return "PhysicalDeviceTextureCompressionAstcHdrFeaturesEXT";
       case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT";
       case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT : return "PhysicalDeviceAstcDecodeFeaturesEXT";
       case StructureType::eImportMemoryWin32HandleInfoKHR : return "ImportMemoryWin32HandleInfoKHR";
@@ -5549,7 +5681,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT";
       case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT";
       case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT";
-      case StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR : return "PhysicalDeviceFloat16Int8FeaturesKHR";
+      case StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR : return "PhysicalDeviceShaderFloat16Int8FeaturesKHR";
       case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR";
       case StructureType::eObjectTableCreateInfoNVX : return "ObjectTableCreateInfoNVX";
       case StructureType::eIndirectCommandsLayoutCreateInfoNVX : return "IndirectCommandsLayoutCreateInfoNVX";
@@ -5668,6 +5800,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT";
       case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
       case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR : return "PhysicalDeviceShaderAtomicInt64FeaturesKHR";
+      case StructureType::ePipelineCompilerControlCreateInfoAMD : return "PipelineCompilerControlCreateInfoAMD";
       case StructureType::eCalibratedTimestampInfoEXT : return "CalibratedTimestampInfoEXT";
       case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD";
       case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD";
@@ -5706,6 +5839,11 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT : return "PhysicalDeviceFragmentDensityMapPropertiesEXT";
       case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT : return "RenderPassFragmentDensityMapCreateInfoEXT";
       case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT : return "PhysicalDeviceScalarBlockLayoutFeaturesEXT";
+      case StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT : return "PhysicalDeviceSubgroupSizeControlPropertiesEXT";
+      case StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT : return "PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT";
+      case StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT : return "PhysicalDeviceSubgroupSizeControlFeaturesEXT";
+      case StructureType::ePhysicalDeviceShaderCoreProperties2AMD : return "PhysicalDeviceShaderCoreProperties2AMD";
+      case StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD : return "PhysicalDeviceCoherentMemoryFeaturesAMD";
       case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT";
       case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT";
       case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT";
@@ -5729,7 +5867,17 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT : return "SurfaceCapabilitiesFullScreenExclusiveEXT";
       case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT : return "SurfaceFullScreenExclusiveWin32InfoEXT";
       case StructureType::eHeadlessSurfaceCreateInfoEXT : return "HeadlessSurfaceCreateInfoEXT";
+      case StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT : return "PhysicalDeviceLineRasterizationFeaturesEXT";
+      case StructureType::ePipelineRasterizationLineStateCreateInfoEXT : return "PipelineRasterizationLineStateCreateInfoEXT";
+      case StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT : return "PhysicalDeviceLineRasterizationPropertiesEXT";
       case StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT : return "PhysicalDeviceHostQueryResetFeaturesEXT";
+      case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT : return "PhysicalDeviceIndexTypeUint8FeaturesEXT";
+      case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR : return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
+      case StructureType::ePipelineInfoKHR : return "PipelineInfoKHR";
+      case StructureType::ePipelineExecutablePropertiesKHR : return "PipelineExecutablePropertiesKHR";
+      case StructureType::ePipelineExecutableInfoKHR : return "PipelineExecutableInfoKHR";
+      case StructureType::ePipelineExecutableStatisticKHR : return "PipelineExecutableStatisticKHR";
+      case StructureType::ePipelineExecutableInternalRepresentationKHR : return "PipelineExecutableInternalRepresentationKHR";
       case StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT : return "PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT";
       case StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT : return "PhysicalDeviceTexelBufferAlignmentFeaturesEXT";
       case StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT : return "PhysicalDeviceTexelBufferAlignmentPropertiesEXT";
@@ -5872,7 +6020,8 @@ namespace VULKAN_HPP_NAMESPACE
   enum class ValidationFeatureEnableEXT
   {
     eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
-    eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT
+    eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
+    eBestPractices = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( ValidationFeatureEnableEXT value )
@@ -5881,6 +6030,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted";
       case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot : return "GpuAssistedReserveBindingSlot";
+      case ValidationFeatureEnableEXT::eBestPractices : return "BestPractices";
       default: return "invalid";
     }
   }
@@ -5947,6 +6097,11 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  template<ObjectType value>
+  struct cpp_type
+  {
+  };
+
   enum class AccessFlagBits
   {
     eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
@@ -8696,7 +8851,9 @@ namespace VULKAN_HPP_NAMESPACE
     eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
     eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
     eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
-    eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT
+    eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT,
+    eDeviceCoherentAMD = VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD,
+    eDeviceUncachedAMD = VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
   };
 
   VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlagBits value )
@@ -8709,6 +8866,8 @@ namespace VULKAN_HPP_NAMESPACE
       case MemoryPropertyFlagBits::eHostCached : return "HostCached";
       case MemoryPropertyFlagBits::eLazilyAllocated : return "LazilyAllocated";
       case MemoryPropertyFlagBits::eProtected : return "Protected";
+      case MemoryPropertyFlagBits::eDeviceCoherentAMD : return "DeviceCoherentAMD";
+      case MemoryPropertyFlagBits::eDeviceUncachedAMD : return "DeviceUncachedAMD";
       default: return "invalid";
     }
   }
@@ -8729,7 +8888,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum
     {
-      allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected)
+      allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected) | VkFlags(MemoryPropertyFlagBits::eDeviceCoherentAMD) | VkFlags(MemoryPropertyFlagBits::eDeviceUncachedAMD)
     };
   };
 
@@ -8744,6 +8903,8 @@ namespace VULKAN_HPP_NAMESPACE
     if ( value & MemoryPropertyFlagBits::eHostCached ) result += "HostCached | ";
     if ( value & MemoryPropertyFlagBits::eLazilyAllocated ) result += "LazilyAllocated | ";
     if ( value & MemoryPropertyFlagBits::eProtected ) result += "Protected | ";
+    if ( value & MemoryPropertyFlagBits::eDeviceCoherentAMD ) result += "DeviceCoherentAMD | ";
+    if ( value & MemoryPropertyFlagBits::eDeviceUncachedAMD ) result += "DeviceUncachedAMD | ";
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
@@ -8898,6 +9059,21 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
+  enum class PipelineCompilerControlFlagBitsAMD
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCompilerControlFlagBitsAMD )
+  {
+    return "(void)";
+  }
+
+  using PipelineCompilerControlFlagsAMD = Flags<PipelineCompilerControlFlagBitsAMD, VkPipelineCompilerControlFlagsAMD>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCompilerControlFlagsAMD  )
+  {
+    return "{}";
+  }
+
   enum class PipelineCoverageModulationStateCreateFlagBitsNV
   {};
 
@@ -8951,6 +9127,8 @@ namespace VULKAN_HPP_NAMESPACE
     eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
     eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE,
     eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV,
+    eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR,
+    eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR,
     eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR,
     eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_KHR
   };
@@ -8965,6 +9143,8 @@ namespace VULKAN_HPP_NAMESPACE
       case PipelineCreateFlagBits::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex";
       case PipelineCreateFlagBits::eDispatchBase : return "DispatchBase";
       case PipelineCreateFlagBits::eDeferCompileNV : return "DeferCompileNV";
+      case PipelineCreateFlagBits::eCaptureStatisticsKHR : return "CaptureStatisticsKHR";
+      case PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR";
       default: return "invalid";
     }
   }
@@ -8985,7 +9165,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum
     {
-      allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV)
+      allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV) | VkFlags(PipelineCreateFlagBits::eCaptureStatisticsKHR) | VkFlags(PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR)
     };
   };
 
@@ -9000,6 +9180,8 @@ namespace VULKAN_HPP_NAMESPACE
     if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex ) result += "ViewIndexFromDeviceIndex | ";
     if ( value & PipelineCreateFlagBits::eDispatchBase ) result += "DispatchBase | ";
     if ( value & PipelineCreateFlagBits::eDeferCompileNV ) result += "DeferCompileNV | ";
+    if ( value & PipelineCreateFlagBits::eCaptureStatisticsKHR ) result += "CaptureStatisticsKHR | ";
+    if ( value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR ) result += "CaptureInternalRepresentationsKHR | ";
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
@@ -9203,18 +9385,49 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   enum class PipelineShaderStageCreateFlagBits
-  {};
+  {
+    eAllowVaryingSubgroupSizeEXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT,
+    eRequireFullSubgroupsEXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT
+  };
 
-  VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlagBits )
+  VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlagBits value )
   {
-    return "(void)";
+    switch ( value )
+    {
+      case PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT : return "AllowVaryingSubgroupSizeEXT";
+      case PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT : return "RequireFullSubgroupsEXT";
+      default: return "invalid";
+    }
   }
 
   using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;
 
-  VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags  )
+  VULKAN_HPP_INLINE PipelineShaderStageCreateFlags operator|( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 )
   {
-    return "{}";
+    return PipelineShaderStageCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE PipelineShaderStageCreateFlags operator~( PipelineShaderStageCreateFlagBits bits )
+  {
+    return ~( PipelineShaderStageCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<PipelineShaderStageCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT) | VkFlags(PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT ) result += "AllowVaryingSubgroupSizeEXT | ";
+    if ( value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT ) result += "RequireFullSubgroupsEXT | ";
+    return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
   enum class PipelineStageFlagBits
@@ -9870,6 +10083,21 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+  enum class ShaderCorePropertiesFlagBitsAMD
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderCorePropertiesFlagBitsAMD )
+  {
+    return "(void)";
+  }
+
+  using ShaderCorePropertiesFlagsAMD = Flags<ShaderCorePropertiesFlagBitsAMD, VkShaderCorePropertiesFlagsAMD>;
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderCorePropertiesFlagsAMD  )
+  {
+    return "{}";
+  }
+
   enum class ShaderModuleCreateFlagBits
   {};
 
@@ -10067,6 +10295,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     eFront = VK_STENCIL_FACE_FRONT_BIT,
     eBack = VK_STENCIL_FACE_BACK_BIT,
+    eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK,
     eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
   };
 
@@ -10076,7 +10305,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case StencilFaceFlagBits::eFront : return "Front";
       case StencilFaceFlagBits::eBack : return "Back";
-      case StencilFaceFlagBits::eVkStencilFrontAndBack : return "VkStencilFrontAndBack";
+      case StencilFaceFlagBits::eFrontAndBack : return "FrontAndBack";
       default: return "invalid";
     }
   }
@@ -10097,7 +10326,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum
     {
-      allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
+      allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eFrontAndBack)
     };
   };
 
@@ -10807,7 +11036,6 @@ namespace VULKAN_HPP_NAMESPACE
       : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
   };
 
-
   VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
   {
     switch ( result )
@@ -11285,6 +11513,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
+  struct PhysicalDeviceCoherentMemoryFeaturesAMD;
   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
   struct PhysicalDeviceConditionalRenderingFeaturesEXT;
   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
@@ -11312,7 +11541,6 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceFeatures;
   struct PhysicalDeviceFeatures2;
   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
-  struct PhysicalDeviceFloat16Int8FeaturesKHR;
   struct PhysicalDeviceFloatControlsPropertiesKHR;
   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
@@ -11328,9 +11556,12 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
   struct PhysicalDeviceImageViewImageFormatInfoEXT;
   struct PhysicalDeviceImagelessFramebufferFeaturesKHR;
+  struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
   struct PhysicalDeviceInlineUniformBlockFeaturesEXT;
   struct PhysicalDeviceInlineUniformBlockPropertiesEXT;
   struct PhysicalDeviceLimits;
+  struct PhysicalDeviceLineRasterizationFeaturesEXT;
+  struct PhysicalDeviceLineRasterizationPropertiesEXT;
   struct PhysicalDeviceMaintenance3Properties;
   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
   struct PhysicalDeviceMemoryBudgetPropertiesEXT;
@@ -11346,6 +11577,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceMultiviewProperties;
   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
   struct PhysicalDevicePCIBusInfoPropertiesEXT;
+  struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
   struct PhysicalDevicePointClippingProperties;
   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
   struct PhysicalDeviceProperties;
@@ -11362,12 +11594,15 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
   struct PhysicalDeviceScalarBlockLayoutFeaturesEXT;
   struct PhysicalDeviceShaderAtomicInt64FeaturesKHR;
+  struct PhysicalDeviceShaderCoreProperties2AMD;
   struct PhysicalDeviceShaderCorePropertiesAMD;
   struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
   struct PhysicalDeviceShaderDrawParametersFeatures;
   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
+  struct PhysicalDeviceShaderFloat16Int8FeaturesKHR;
+  using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8FeaturesKHR;
   struct PhysicalDeviceShaderImageFootprintFeaturesNV;
-  struct PhysicalDeviceShaderIntegerFunctions2INTEL;
+  struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
   struct PhysicalDeviceShadingRateImageFeaturesNV;
@@ -11376,9 +11611,12 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
   struct PhysicalDeviceSparseProperties;
   struct PhysicalDeviceSubgroupProperties;
+  struct PhysicalDeviceSubgroupSizeControlFeaturesEXT;
+  struct PhysicalDeviceSubgroupSizeControlPropertiesEXT;
   struct PhysicalDeviceSurfaceInfo2KHR;
   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
   struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+  struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
   struct PhysicalDeviceTransformFeedbackFeaturesEXT;
   struct PhysicalDeviceTransformFeedbackPropertiesEXT;
   struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
@@ -11394,6 +11632,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineColorBlendAdvancedStateCreateInfoEXT;
   struct PipelineColorBlendAttachmentState;
   struct PipelineColorBlendStateCreateInfo;
+  struct PipelineCompilerControlCreateInfoAMD;
   struct PipelineCoverageModulationStateCreateInfoNV;
   struct PipelineCoverageReductionStateCreateInfoNV;
   struct PipelineCoverageToColorStateCreateInfoNV;
@@ -11402,17 +11641,25 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineDepthStencilStateCreateInfo;
   struct PipelineDiscardRectangleStateCreateInfoEXT;
   struct PipelineDynamicStateCreateInfo;
+  struct PipelineExecutableInfoKHR;
+  struct PipelineExecutableInternalRepresentationKHR;
+  struct PipelineExecutablePropertiesKHR;
+  struct PipelineExecutableStatisticKHR;
+  union PipelineExecutableStatisticValueKHR;
+  struct PipelineInfoKHR;
   struct PipelineInputAssemblyStateCreateInfo;
   struct PipelineLayoutCreateInfo;
   struct PipelineMultisampleStateCreateInfo;
   struct PipelineRasterizationConservativeStateCreateInfoEXT;
   struct PipelineRasterizationDepthClipStateCreateInfoEXT;
+  struct PipelineRasterizationLineStateCreateInfoEXT;
   struct PipelineRasterizationStateCreateInfo;
   struct PipelineRasterizationStateRasterizationOrderAMD;
   struct PipelineRasterizationStateStreamCreateInfoEXT;
   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
   struct PipelineSampleLocationsStateCreateInfoEXT;
   struct PipelineShaderStageCreateInfo;
+  struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
   struct PipelineTessellationDomainOriginStateCreateInfo;
   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
   struct PipelineTessellationStateCreateInfo;
@@ -11562,6 +11809,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkSurfaceKHR;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR;
+
   public:
     VULKAN_HPP_CONSTEXPR SurfaceKHR()
       : m_surfaceKHR(VK_NULL_HANDLE)
@@ -11624,11 +11873,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eSurfaceKHR>
+  {
+    using type = SurfaceKHR;
+  };
+
   class DebugReportCallbackEXT
   {
   public:
     using CType = VkDebugReportCallbackEXT;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT;
+
   public:
     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
       : m_debugReportCallbackEXT(VK_NULL_HANDLE)
@@ -11691,11 +11948,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDebugReportCallbackEXT>
+  {
+    using type = DebugReportCallbackEXT;
+  };
+
   class DebugUtilsMessengerEXT
   {
   public:
     using CType = VkDebugUtilsMessengerEXT;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT;
+
   public:
     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
       : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
@@ -11758,11 +12023,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDebugUtilsMessengerEXT>
+  {
+    using type = DebugUtilsMessengerEXT;
+  };
+
   class DisplayKHR
   {
   public:
     using CType = VkDisplayKHR;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR;
+
   public:
     VULKAN_HPP_CONSTEXPR DisplayKHR()
       : m_displayKHR(VK_NULL_HANDLE)
@@ -11825,11 +12098,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDisplayKHR>
+  {
+    using type = DisplayKHR;
+  };
+
   class SwapchainKHR
   {
   public:
     using CType = VkSwapchainKHR;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR;
+
   public:
     VULKAN_HPP_CONSTEXPR SwapchainKHR()
       : m_swapchainKHR(VK_NULL_HANDLE)
@@ -11892,11 +12173,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eSwapchainKHR>
+  {
+    using type = SwapchainKHR;
+  };
+
   class Semaphore
   {
   public:
     using CType = VkSemaphore;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore;
+
   public:
     VULKAN_HPP_CONSTEXPR Semaphore()
       : m_semaphore(VK_NULL_HANDLE)
@@ -11959,11 +12248,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eSemaphore>
+  {
+    using type = Semaphore;
+  };
+
   class Fence
   {
   public:
     using CType = VkFence;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence;
+
   public:
     VULKAN_HPP_CONSTEXPR Fence()
       : m_fence(VK_NULL_HANDLE)
@@ -12026,11 +12323,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eFence>
+  {
+    using type = Fence;
+  };
+
   class PerformanceConfigurationINTEL
   {
   public:
     using CType = VkPerformanceConfigurationINTEL;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL;
+
   public:
     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL()
       : m_performanceConfigurationINTEL(VK_NULL_HANDLE)
@@ -12093,11 +12398,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::ePerformanceConfigurationINTEL>
+  {
+    using type = PerformanceConfigurationINTEL;
+  };
+
   class QueryPool
   {
   public:
     using CType = VkQueryPool;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool;
+
   public:
     VULKAN_HPP_CONSTEXPR QueryPool()
       : m_queryPool(VK_NULL_HANDLE)
@@ -12160,11 +12473,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eQueryPool>
+  {
+    using type = QueryPool;
+  };
+
   class Buffer
   {
   public:
     using CType = VkBuffer;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer;
+
   public:
     VULKAN_HPP_CONSTEXPR Buffer()
       : m_buffer(VK_NULL_HANDLE)
@@ -12227,11 +12548,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eBuffer>
+  {
+    using type = Buffer;
+  };
+
   class PipelineLayout
   {
   public:
     using CType = VkPipelineLayout;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout;
+
   public:
     VULKAN_HPP_CONSTEXPR PipelineLayout()
       : m_pipelineLayout(VK_NULL_HANDLE)
@@ -12294,11 +12623,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::ePipelineLayout>
+  {
+    using type = PipelineLayout;
+  };
+
   class DescriptorSet
   {
   public:
     using CType = VkDescriptorSet;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet;
+
   public:
     VULKAN_HPP_CONSTEXPR DescriptorSet()
       : m_descriptorSet(VK_NULL_HANDLE)
@@ -12361,11 +12698,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDescriptorSet>
+  {
+    using type = DescriptorSet;
+  };
+
   class Pipeline
   {
   public:
     using CType = VkPipeline;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline;
+
   public:
     VULKAN_HPP_CONSTEXPR Pipeline()
       : m_pipeline(VK_NULL_HANDLE)
@@ -12428,11 +12773,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::ePipeline>
+  {
+    using type = Pipeline;
+  };
+
   class ImageView
   {
   public:
     using CType = VkImageView;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView;
+
   public:
     VULKAN_HPP_CONSTEXPR ImageView()
       : m_imageView(VK_NULL_HANDLE)
@@ -12495,11 +12848,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eImageView>
+  {
+    using type = ImageView;
+  };
+
   class Image
   {
   public:
     using CType = VkImage;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage;
+
   public:
     VULKAN_HPP_CONSTEXPR Image()
       : m_image(VK_NULL_HANDLE)
@@ -12562,11 +12923,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eImage>
+  {
+    using type = Image;
+  };
+
   class AccelerationStructureNV
   {
   public:
     using CType = VkAccelerationStructureNV;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV;
+
   public:
     VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
       : m_accelerationStructureNV(VK_NULL_HANDLE)
@@ -12629,11 +12998,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eAccelerationStructureNV>
+  {
+    using type = AccelerationStructureNV;
+  };
+
   class DescriptorUpdateTemplate
   {
   public:
     using CType = VkDescriptorUpdateTemplate;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate;
+
   public:
     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
       : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
@@ -12695,6 +13072,12 @@ namespace VULKAN_HPP_NAMESPACE
     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
   };
   static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
+
+  template <>
+  struct cpp_type<ObjectType::eDescriptorUpdateTemplate>
+  {
+    using type = DescriptorUpdateTemplate;
+  };
   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
 
   class Event
@@ -12702,6 +13085,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkEvent;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent;
+
   public:
     VULKAN_HPP_CONSTEXPR Event()
       : m_event(VK_NULL_HANDLE)
@@ -12764,11 +13149,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eEvent>
+  {
+    using type = Event;
+  };
+
   class CommandBuffer
   {
   public:
     using CType = VkCommandBuffer;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer;
+
   public:
     VULKAN_HPP_CONSTEXPR CommandBuffer()
       : m_commandBuffer(VK_NULL_HANDLE)
@@ -12812,154 +13205,154 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = Dispatch() ) const;
+    Result begin( const vk::CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
+    void beginConditionalRenderingEXT( const vk::ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+    void beginDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d = Dispatch() ) const;
+    void beginQuery( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d = Dispatch() ) const;
+    void beginQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, uint32_t index, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+    void beginRenderPass( const vk::RenderPassBeginInfo* pRenderPassBegin, vk::SubpassContents contents, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+    void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, vk::SubpassContents contents, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d = Dispatch() ) const;
+    void beginRenderPass2KHR( const vk::RenderPassBeginInfo* pRenderPassBegin, const vk::SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+    void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer* pCounterBuffers, const vk::DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+    void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const vk::Buffer> counterBuffers, ArrayProxy<const vk::DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = Dispatch() ) const;
+    void bindDescriptorSets( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d = Dispatch() ) const;
+    void bindDescriptorSets( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, ArrayProxy<const vk::DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d = Dispatch() ) const;
+    void bindIndexBuffer( vk::Buffer buffer, vk::DeviceSize offset, vk::IndexType indexType, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d = Dispatch() ) const;
+    void bindPipeline( vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const;
+    void bindShadingRateImageNV( vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d = Dispatch() ) const;
+    void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer* pBuffers, const vk::DeviceSize* pOffsets, const vk::DeviceSize* pSizes, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d = Dispatch() ) const;
+    void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const vk::Buffer> buffers, ArrayProxy<const vk::DeviceSize> offsets, ArrayProxy<const vk::DeviceSize> sizes, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d = Dispatch() ) const;
+    void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer* pBuffers, const vk::DeviceSize* pOffsets, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, Dispatch const &d = Dispatch() ) const;
+    void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const vk::Buffer> buffers, ArrayProxy<const vk::DeviceSize> offsets, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d = Dispatch() ) const;
+    void blitImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageBlit* pRegions, vk::Filter filter, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter, Dispatch const &d = Dispatch() ) const;
+    void blitImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageBlit> regions, vk::Filter filter, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+    void buildAccelerationStructureNV( const vk::AccelerationStructureInfoNV* pInfo, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+    void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d = Dispatch() ) const;
+    void clearAttachments( uint32_t attachmentCount, const vk::ClearAttachment* pAttachments, uint32_t rectCount, const vk::ClearRect* pRects, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects, Dispatch const &d = Dispatch() ) const;
+    void clearAttachments( ArrayProxy<const vk::ClearAttachment> attachments, ArrayProxy<const vk::ClearRect> rects, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
+    void clearColorImage( vk::Image image, vk::ImageLayout imageLayout, const vk::ClearColorValue* pColor, uint32_t rangeCount, const vk::ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
+    void clearColorImage( vk::Image image, vk::ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const vk::ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
+    void clearDepthStencilImage( vk::Image image, vk::ImageLayout imageLayout, const vk::ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const vk::ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
+    void clearDepthStencilImage( vk::Image image, vk::ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const vk::ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d = Dispatch() ) const;
+    void copyAccelerationStructureNV( vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::CopyAccelerationStructureModeNV mode, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+    void copyBuffer( vk::Buffer srcBuffer, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferCopy* pRegions, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d = Dispatch() ) const;
+    void copyBuffer( vk::Buffer srcBuffer, vk::Buffer dstBuffer, ArrayProxy<const vk::BufferCopy> regions, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+    void copyBufferToImage( vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+    void copyBufferToImage( vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+    void copyImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+    void copyImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageCopy> regions, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+    void copyImageToBuffer( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+    void copyImageToBuffer( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, ArrayProxy<const vk::BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+    void copyQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+    void debugMarkerBeginEXT( const vk::DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
@@ -12969,7 +13362,7 @@ namespace VULKAN_HPP_NAMESPACE
     void debugMarkerEndEXT(Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+    void debugMarkerInsertEXT( const vk::DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
@@ -12985,7 +13378,7 @@ namespace VULKAN_HPP_NAMESPACE
     void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d = Dispatch() ) const;
+    void dispatchIndirect( vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
     void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
@@ -12994,31 +13387,31 @@ namespace VULKAN_HPP_NAMESPACE
     void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+    void drawIndexedIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+    void drawIndexedIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+    void drawIndexedIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+    void drawIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = Dispatch() ) const;
+    void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, vk::Buffer counterBuffer, vk::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+    void drawIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+    void drawIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+    void drawMeshTasksIndirectCountNV( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+    void drawMeshTasksIndirectNV( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
     void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = Dispatch() ) const;
@@ -13030,104 +13423,104 @@ namespace VULKAN_HPP_NAMESPACE
     void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
+    void endQuery( vk::QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = Dispatch() ) const;
+    void endQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
     void endRenderPass(Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
+    void endRenderPass2KHR( const vk::SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+    void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer* pCounterBuffers, const vk::DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+    void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const vk::Buffer> counterBuffers, ArrayProxy<const vk::DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+    void executeCommands( uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+    void executeCommands( ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d = Dispatch() ) const;
+    void fillBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize size, uint32_t data, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+    void insertDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void nextSubpass( SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+    void nextSubpass( vk::SubpassContents contents, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
+    void nextSubpass2KHR( const vk::SubpassBeginInfoKHR* pSubpassBeginInfo, const vk::SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+    void pipelineBarrier( vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const vk::MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+    void pipelineBarrier( vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, ArrayProxy<const vk::MemoryBarrier> memoryBarriers, ArrayProxy<const vk::BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const vk::ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = Dispatch() ) const;
+    void processCommandsNVX( const vk::CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = Dispatch() ) const;
+    void pushConstants( vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename T, typename Dispatch = DispatchLoaderDefault>
-    void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d = Dispatch() ) const;
+    void pushConstants( vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = Dispatch() ) const;
+    void pushDescriptorSetKHR( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const vk::WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d = Dispatch() ) const;
+    void pushDescriptorSetKHR( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, ArrayProxy<const vk::WriteDescriptorSet> descriptorWrites, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const;
+    void pushDescriptorSetWithTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
+    void reserveSpaceForCommandsNVX( const vk::CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
+    void resetEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
+    void resetQueryPool( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d = Dispatch() ) const;
+    void resolveImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageResolve* pRegions, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d = Dispatch() ) const;
+    void resolveImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageResolve> regions, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
@@ -13137,10 +13530,10 @@ namespace VULKAN_HPP_NAMESPACE
     void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const;
+    void setCoarseSampleOrderNV( vk::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = Dispatch() ) const;
+    void setCoarseSampleOrderNV( vk::CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const vk::CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
@@ -13156,119 +13549,122 @@ namespace VULKAN_HPP_NAMESPACE
     void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d = Dispatch() ) const;
+    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const vk::Rect2D* pDiscardRectangles, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d = Dispatch() ) const;
+    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const vk::Rect2D> discardRectangles, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
+    void setEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const;
+    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const vk::Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d = Dispatch() ) const;
+    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const vk::Rect2D> exclusiveScissors, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
+    void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderDefault>
     void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+    Result setPerformanceMarkerINTEL( const vk::PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d = Dispatch() ) const;
+    Result setPerformanceOverrideINTEL( const vk::PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+    Result setPerformanceStreamMarkerINTEL( const vk::PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
+    void setSampleLocationsEXT( const vk::SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d = Dispatch() ) const;
+    void setScissor( uint32_t firstScissor, uint32_t scissorCount, const vk::Rect2D* pScissors, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d = Dispatch() ) const;
+    void setScissor( uint32_t firstScissor, ArrayProxy<const vk::Rect2D> scissors, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const;
+    void setStencilCompareMask( vk::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const;
+    void setStencilReference( vk::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = Dispatch() ) const;
+    void setStencilWriteMask( vk::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d = Dispatch() ) const;
+    void setViewport( uint32_t firstViewport, uint32_t viewportCount, const vk::Viewport* pViewports, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d = Dispatch() ) const;
+    void setViewport( uint32_t firstViewport, ArrayProxy<const vk::Viewport> viewports, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+    void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const vk::ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+    void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const vk::ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d = Dispatch() ) const;
+    void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const vk::ViewportWScalingNV* pViewportWScalings, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d = Dispatch() ) const;
+    void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const vk::ViewportWScalingNV> viewportWScalings, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const;
+    void traceRaysNV( vk::Buffer raygenShaderBindingTableBuffer, vk::DeviceSize raygenShaderBindingOffset, vk::Buffer missShaderBindingTableBuffer, vk::DeviceSize missShaderBindingOffset, vk::DeviceSize missShaderBindingStride, vk::Buffer hitShaderBindingTableBuffer, vk::DeviceSize hitShaderBindingOffset, vk::DeviceSize hitShaderBindingStride, vk::Buffer callableShaderBindingTableBuffer, vk::DeviceSize callableShaderBindingOffset, vk::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d = Dispatch() ) const;
+    void updateBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize dataSize, const void* pData, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename T, typename Dispatch = DispatchLoaderDefault>
-    void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d = Dispatch() ) const;
+    void updateBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+    void waitEvents( uint32_t eventCount, const vk::Event* pEvents, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const vk::MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+    void waitEvents( ArrayProxy<const vk::Event> events, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, ArrayProxy<const vk::MemoryBarrier> memoryBarriers, ArrayProxy<const vk::BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const vk::ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
+    void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const vk::AccelerationStructureNV* pAccelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
+    void writeAccelerationStructuresPropertiesNV( ArrayProxy<const vk::AccelerationStructureNV> accelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d = Dispatch() ) const;
+    void writeBufferMarkerAMD( vk::PipelineStageFlagBits pipelineStage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
+    void writeTimestamp( vk::PipelineStageFlagBits pipelineStage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
@@ -13280,10 +13676,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
+    Result reset( vk::CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type reset( vk::CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
@@ -13306,11 +13702,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eCommandBuffer>
+  {
+    using type = CommandBuffer;
+  };
+
   class DeviceMemory
   {
   public:
     using CType = VkDeviceMemory;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory;
+
   public:
     VULKAN_HPP_CONSTEXPR DeviceMemory()
       : m_deviceMemory(VK_NULL_HANDLE)
@@ -13373,11 +13777,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDeviceMemory>
+  {
+    using type = DeviceMemory;
+  };
+
   class BufferView
   {
   public:
     using CType = VkBufferView;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView;
+
   public:
     VULKAN_HPP_CONSTEXPR BufferView()
       : m_bufferView(VK_NULL_HANDLE)
@@ -13440,11 +13852,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eBufferView>
+  {
+    using type = BufferView;
+  };
+
   class CommandPool
   {
   public:
     using CType = VkCommandPool;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool;
+
   public:
     VULKAN_HPP_CONSTEXPR CommandPool()
       : m_commandPool(VK_NULL_HANDLE)
@@ -13507,11 +13927,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eCommandPool>
+  {
+    using type = CommandPool;
+  };
+
   class PipelineCache
   {
   public:
     using CType = VkPipelineCache;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache;
+
   public:
     VULKAN_HPP_CONSTEXPR PipelineCache()
       : m_pipelineCache(VK_NULL_HANDLE)
@@ -13574,11 +14002,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::ePipelineCache>
+  {
+    using type = PipelineCache;
+  };
+
   class DescriptorPool
   {
   public:
     using CType = VkDescriptorPool;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool;
+
   public:
     VULKAN_HPP_CONSTEXPR DescriptorPool()
       : m_descriptorPool(VK_NULL_HANDLE)
@@ -13641,11 +14077,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDescriptorPool>
+  {
+    using type = DescriptorPool;
+  };
+
   class DescriptorSetLayout
   {
   public:
     using CType = VkDescriptorSetLayout;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout;
+
   public:
     VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
       : m_descriptorSetLayout(VK_NULL_HANDLE)
@@ -13708,11 +14152,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDescriptorSetLayout>
+  {
+    using type = DescriptorSetLayout;
+  };
+
   class Framebuffer
   {
   public:
     using CType = VkFramebuffer;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer;
+
   public:
     VULKAN_HPP_CONSTEXPR Framebuffer()
       : m_framebuffer(VK_NULL_HANDLE)
@@ -13775,11 +14227,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eFramebuffer>
+  {
+    using type = Framebuffer;
+  };
+
   class IndirectCommandsLayoutNVX
   {
   public:
     using CType = VkIndirectCommandsLayoutNVX;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNVX;
+
   public:
     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
       : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
@@ -13842,11 +14302,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eIndirectCommandsLayoutNVX>
+  {
+    using type = IndirectCommandsLayoutNVX;
+  };
+
   class ObjectTableNVX
   {
   public:
     using CType = VkObjectTableNVX;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eObjectTableNVX;
+
   public:
     VULKAN_HPP_CONSTEXPR ObjectTableNVX()
       : m_objectTableNVX(VK_NULL_HANDLE)
@@ -13909,11 +14377,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eObjectTableNVX>
+  {
+    using type = ObjectTableNVX;
+  };
+
   class RenderPass
   {
   public:
     using CType = VkRenderPass;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass;
+
   public:
     VULKAN_HPP_CONSTEXPR RenderPass()
       : m_renderPass(VK_NULL_HANDLE)
@@ -13976,11 +14452,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eRenderPass>
+  {
+    using type = RenderPass;
+  };
+
   class Sampler
   {
   public:
     using CType = VkSampler;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler;
+
   public:
     VULKAN_HPP_CONSTEXPR Sampler()
       : m_sampler(VK_NULL_HANDLE)
@@ -14043,11 +14527,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eSampler>
+  {
+    using type = Sampler;
+  };
+
   class SamplerYcbcrConversion
   {
   public:
     using CType = VkSamplerYcbcrConversion;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion;
+
   public:
     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
       : m_samplerYcbcrConversion(VK_NULL_HANDLE)
@@ -14109,6 +14601,12 @@ namespace VULKAN_HPP_NAMESPACE
     VkSamplerYcbcrConversion m_samplerYcbcrConversion;
   };
   static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
+
+  template <>
+  struct cpp_type<ObjectType::eSamplerYcbcrConversion>
+  {
+    using type = SamplerYcbcrConversion;
+  };
   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
 
   class ShaderModule
@@ -14116,6 +14614,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkShaderModule;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule;
+
   public:
     VULKAN_HPP_CONSTEXPR ShaderModule()
       : m_shaderModule(VK_NULL_HANDLE)
@@ -14178,11 +14678,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eShaderModule>
+  {
+    using type = ShaderModule;
+  };
+
   class ValidationCacheEXT
   {
   public:
     using CType = VkValidationCacheEXT;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT;
+
   public:
     VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
       : m_validationCacheEXT(VK_NULL_HANDLE)
@@ -14245,11 +14753,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eValidationCacheEXT>
+  {
+    using type = ValidationCacheEXT;
+  };
+
   class Queue
   {
   public:
     using CType = VkQueue;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue;
+
   public:
     VULKAN_HPP_CONSTEXPR Queue()
       : m_queue(VK_NULL_HANDLE)
@@ -14293,7 +14809,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d = Dispatch() ) const;
+    void getCheckpointDataNV( uint32_t* pCheckpointDataCount, vk::CheckpointDataNV* pCheckpointData, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderDefault>
     std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Dispatch const &d = Dispatch() ) const;
@@ -14302,31 +14818,31 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+    void beginDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
+    Result bindSparse( uint32_t bindInfoCount, const vk::BindSparseInfo* pBindInfo, vk::Fence fence, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type bindSparse( ArrayProxy<const vk::BindSparseInfo> bindInfo, vk::Fence fence, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
     void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+    void insertDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d = Dispatch() ) const;
+    Result presentKHR( const vk::PresentInfoKHR* pPresentInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = Dispatch() ) const;
@@ -14334,17 +14850,17 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
+    Result setPerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type setPerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d = Dispatch() ) const;
+    Result submit( uint32_t submitCount, const vk::SubmitInfo* pSubmits, vk::Fence fence, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type submit( ArrayProxy<const vk::SubmitInfo> submits, vk::Fence fence, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -14375,6 +14891,12 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eQueue>
+  {
+    using type = Queue;
+  };
+
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   class Device;
   template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
@@ -14440,6 +14962,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkDevice;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice;
+
   public:
     VULKAN_HPP_CONSTEXPR Device()
       : m_device(VK_NULL_HANDLE)
@@ -14485,36 +15009,36 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    Result acquireFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type acquireFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
+    Result acquireNextImage2KHR( const vk::AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValue<uint32_t> acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
+    Result acquireNextImageKHR( vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d = Dispatch() ) const;
+    ResultValue<uint32_t> acquireNextImageKHR( vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d = Dispatch() ) const;
+    Result acquirePerformanceConfigurationINTEL( const vk::PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, vk::PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<PerformanceConfigurationINTEL>::type acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::PerformanceConfigurationINTEL>::type acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+    Result allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
@@ -14529,7 +15053,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+    Result allocateDescriptorSets( const vk::DescriptorSetAllocateInfo* pAllocateInfo, vk::DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
@@ -14544,10 +15068,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d = Dispatch() ) const;
+    Result allocateMemory( const vk::MemoryAllocateInfo* pAllocateInfo, const vk::AllocationCallbacks* pAllocator, vk::DeviceMemory* pMemory, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<DeviceMemory,Dispatch>>::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14555,69 +15079,69 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const;
+    Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const vk::BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type bindAccelerationStructureMemoryNV( ArrayProxy<const vk::BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+    Result bindBufferMemory( vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type bindBufferMemory( vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+    Result bindBufferMemory2( uint32_t bindInfoCount, const vk::BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type bindBufferMemory2( ArrayProxy<const vk::BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+    Result bindBufferMemory2KHR( uint32_t bindInfoCount, const vk::BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type bindBufferMemory2KHR( ArrayProxy<const vk::BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+    Result bindImageMemory( vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type bindImageMemory( vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+    Result bindImageMemory2( uint32_t bindInfoCount, const vk::BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type bindImageMemory2( ArrayProxy<const vk::BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+    Result bindImageMemory2KHR( uint32_t bindInfoCount, const vk::BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type bindImageMemory2KHR( ArrayProxy<const vk::BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+    Result compileDeferredNV( vk::Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type compileDeferredNV( vk::Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const;
+    Result createAccelerationStructureNV( const vk::AccelerationStructureCreateInfoNV* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<AccelerationStructureNV>::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::AccelerationStructureNV>::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14625,10 +15149,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d = Dispatch() ) const;
+    Result createBuffer( const vk::BufferCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Buffer* pBuffer, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14636,10 +15160,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d = Dispatch() ) const;
+    Result createBufferView( const vk::BufferViewCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::BufferView* pView, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14647,10 +15171,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d = Dispatch() ) const;
+    Result createCommandPool( const vk::CommandPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::CommandPool* pCommandPool, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14658,29 +15182,29 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+    Result createComputePipelines( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::ComputePipelineCreateInfo* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<Pipeline>::type createComputePipeline( vk::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
     template<typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createComputePipelineUnique( vk::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d = Dispatch() ) const;
+    Result createDescriptorPool( const vk::DescriptorPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorPool* pDescriptorPool, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14688,10 +15212,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d = Dispatch() ) const;
+    Result createDescriptorSetLayout( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorSetLayout* pSetLayout, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14699,10 +15223,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
+    Result createDescriptorUpdateTemplate( const vk::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14710,10 +15234,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
+    Result createDescriptorUpdateTemplateKHR( const vk::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14721,10 +15245,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d = Dispatch() ) const;
+    Result createEvent( const vk::EventCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Event* pEvent, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<Event,Dispatch>>::type createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14732,10 +15256,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+    Result createFence( const vk::FenceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14743,10 +15267,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d = Dispatch() ) const;
+    Result createFramebuffer( const vk::FramebufferCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Framebuffer* pFramebuffer, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14754,29 +15278,29 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+    Result createGraphicsPipelines( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::GraphicsPipelineCreateInfo* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<Pipeline>::type createGraphicsPipeline( vk::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
     template<typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createGraphicsPipelineUnique( vk::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d = Dispatch() ) const;
+    Result createImage( const vk::ImageCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Image* pImage, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<Image,Dispatch>>::type createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14784,10 +15308,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d = Dispatch() ) const;
+    Result createImageView( const vk::ImageViewCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ImageView* pView, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14795,10 +15319,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = Dispatch() ) const;
+    Result createIndirectCommandsLayoutNVX( const vk::IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<IndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::IndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14806,10 +15330,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d = Dispatch() ) const;
+    Result createObjectTableNVX( const vk::ObjectTableCreateInfoNVX* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ObjectTableNVX* pObjectTable, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14817,10 +15341,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d = Dispatch() ) const;
+    Result createPipelineCache( const vk::PipelineCacheCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::PipelineCache* pPipelineCache, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14828,10 +15352,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d = Dispatch() ) const;
+    Result createPipelineLayout( const vk::PipelineLayoutCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::PipelineLayout* pPipelineLayout, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14839,10 +15363,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d = Dispatch() ) const;
+    Result createQueryPool( const vk::QueryPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::QueryPool* pQueryPool, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14850,29 +15374,29 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+    Result createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::RayTracingPipelineCreateInfoNV* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Pipeline>::type createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<Pipeline>::type createRayTracingPipelineNV( vk::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
     template<typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createRayTracingPipelineNVUnique( vk::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
+    Result createRenderPass( const vk::RenderPassCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14880,10 +15404,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
+    Result createRenderPass2KHR( const vk::RenderPassCreateInfo2KHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<RenderPass>::type createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::RenderPass>::type createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14891,10 +15415,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d = Dispatch() ) const;
+    Result createSampler( const vk::SamplerCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Sampler* pSampler, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14902,10 +15426,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
+    Result createSamplerYcbcrConversion( const vk::SamplerYcbcrConversionCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14913,10 +15437,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
+    Result createSamplerYcbcrConversionKHR( const vk::SamplerYcbcrConversionCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14924,10 +15448,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d = Dispatch() ) const;
+    Result createSemaphore( const vk::SemaphoreCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Semaphore* pSemaphore, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14935,10 +15459,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d = Dispatch() ) const;
+    Result createShaderModule( const vk::ShaderModuleCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ShaderModule* pShaderModule, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14946,29 +15470,29 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d = Dispatch() ) const;
+    Result createSharedSwapchainsKHR( uint32_t swapchainCount, const vk::SwapchainCreateInfoKHR* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::SwapchainKHR* pSwapchains, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d = Dispatch() ) const;
+    Result createSwapchainKHR( const vk::SwapchainCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SwapchainKHR* pSwapchain, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14976,10 +15500,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d = Dispatch() ) const;
+    Result createValidationCacheEXT( const vk::ValidationCacheCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ValidationCacheEXT* pValidationCache, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ValidationCacheEXT>::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ValidationCacheEXT>::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -14987,388 +15511,388 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
+    Result debugMarkerSetObjectNameEXT( const vk::DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
+    Result debugMarkerSetObjectTagEXT( const vk::DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyAccelerationStructureNV( vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyAccelerationStructureNV( vk::AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyBuffer( vk::Buffer buffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyBuffer( vk::Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Buffer buffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyBufferView( vk::BufferView bufferView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyBufferView( vk::BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::BufferView bufferView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyCommandPool( vk::CommandPool commandPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyCommandPool( vk::CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::CommandPool commandPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyDescriptorPool( vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyDescriptorPool( vk::DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyDescriptorUpdateTemplate( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyDescriptorUpdateTemplate( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyDescriptorUpdateTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyDescriptorUpdateTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyEvent( vk::Event event, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyEvent( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyEvent( vk::Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Event event, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyFence( vk::Fence fence, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyFence( vk::Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Fence fence, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyFramebuffer( vk::Framebuffer framebuffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyFramebuffer( vk::Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Framebuffer framebuffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyImage( vk::Image image, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyImage( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyImage( vk::Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Image image, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyImageView( vk::ImageView imageView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyImageView( vk::ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::ImageView imageView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyIndirectCommandsLayoutNVX( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyIndirectCommandsLayoutNVX( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyObjectTableNVX( vk::ObjectTableNVX objectTable, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyObjectTableNVX( vk::ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::ObjectTableNVX objectTable, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyPipeline( vk::Pipeline pipeline, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyPipeline( vk::Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Pipeline pipeline, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyPipelineCache( vk::PipelineCache pipelineCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyPipelineCache( vk::PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::PipelineCache pipelineCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyPipelineLayout( vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyPipelineLayout( vk::PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyQueryPool( vk::QueryPool queryPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyQueryPool( vk::QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::QueryPool queryPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyRenderPass( vk::RenderPass renderPass, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyRenderPass( vk::RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::RenderPass renderPass, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroySampler( vk::Sampler sampler, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroySampler( vk::Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Sampler sampler, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroySamplerYcbcrConversion( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroySamplerYcbcrConversion( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroySamplerYcbcrConversionKHR( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroySamplerYcbcrConversionKHR( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroySemaphore( vk::Semaphore semaphore, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroySemaphore( vk::Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Semaphore semaphore, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyShaderModule( vk::ShaderModule shaderModule, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyShaderModule( vk::ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::ShaderModule shaderModule, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroySwapchainKHR( vk::SwapchainKHR swapchain, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroySwapchainKHR( vk::SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::SwapchainKHR swapchain, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyValidationCacheEXT( vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyValidationCacheEXT( vk::ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -15380,187 +15904,187 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = Dispatch() ) const;
+    Result displayPowerControlEXT( vk::DisplayKHR display, const vk::DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type displayPowerControlEXT( vk::DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
+    Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const vk::MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const vk::MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+    void freeCommandBuffers( vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+    void freeCommandBuffers( vk::CommandPool commandPool, ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+    void free( vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+    void free( vk::CommandPool commandPool, ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+    Result freeDescriptorSets( vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type freeDescriptorSets( vk::DescriptorPool descriptorPool, ArrayProxy<const vk::DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+    Result free( vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type free( vk::DescriptorPool descriptorPool, ArrayProxy<const vk::DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void freeMemory( vk::DeviceMemory memory, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void freeMemory( vk::DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void free( vk::DeviceMemory memory, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void free( vk::DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+    Result getAccelerationStructureHandleNV( vk::AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename T, typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type getAccelerationStructureHandleNV( vk::AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getAccelerationStructureMemoryRequirementsNV( const vk::AccelerationStructureMemoryRequirementsInfoNV* pInfo, vk::MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
+    vk::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, vk::AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d = Dispatch() ) const;
+    DeviceAddress getBufferAddressEXT( const vk::BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getBufferMemoryRequirements( vk::Buffer buffer, vk::MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    MemoryRequirements getBufferMemoryRequirements( Buffer buffer, Dispatch const &d = Dispatch() ) const;
+    vk::MemoryRequirements getBufferMemoryRequirements( vk::Buffer buffer, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getBufferMemoryRequirements2( const vk::BufferMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    vk::MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getBufferMemoryRequirements2KHR( const vk::BufferMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    vk::MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = Dispatch() ) const;
+    Result getCalibratedTimestampsEXT( uint32_t timestampCount, const vk::CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<uint64_t>::type getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<uint64_t>::type getCalibratedTimestampsEXT( ArrayProxy<const vk::CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
+    void getDescriptorSetLayoutSupport( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, vk::DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+    vk::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
+    void getDescriptorSetLayoutSupportKHR( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, vk::DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+    vk::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
+    void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
+    vk::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
+    void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
+    vk::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = Dispatch() ) const;
+    Result getGroupPresentCapabilitiesKHR( vk::DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const;
+    Result getGroupSurfacePresentModes2EXT( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, vk::DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const;
+    Result getGroupSurfacePresentModesKHR( vk::SurfaceKHR surface, vk::DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( vk::SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = Dispatch() ) const;
+    void getMemoryCommitment( vk::DeviceMemory memory, vk::DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    DeviceSize getMemoryCommitment( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
+    vk::DeviceSize getMemoryCommitment( vk::DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
@@ -15571,35 +16095,35 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
+    void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, vk::Queue* pQueue, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = Dispatch() ) const;
+    vk::Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
+    void getQueue2( const vk::DeviceQueueInfo2* pQueueInfo, vk::Queue* pQueue, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = Dispatch() ) const;
+    vk::Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getEventStatus( Event event, Dispatch const &d = Dispatch() ) const;
+    Result getEventStatus( vk::Event event, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+    Result getFenceFdKHR( const vk::FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getFenceStatus( Fence fence, Dispatch const &d = Dispatch() ) const;
+    Result getFenceStatus( vk::Fence fence, Dispatch const &d = Dispatch() ) const;
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+    Result getFenceWin32HandleKHR( const vk::FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
@@ -15607,48 +16131,48 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getImageDrmFormatModifierPropertiesEXT( vk::Image image, vk::ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( vk::Image image, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getImageMemoryRequirements( vk::Image image, vk::MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    MemoryRequirements getImageMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
+    vk::MemoryRequirements getImageMemoryRequirements( vk::Image image, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getImageMemoryRequirements2( const vk::ImageMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    vk::MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getImageMemoryRequirements2KHR( const vk::ImageMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    vk::MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getImageSparseMemoryRequirements( vk::Image image, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderDefault>
-    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
+    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( vk::Image image, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderDefault>
-    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( vk::Image image, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getImageSparseMemoryRequirements2( const vk::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderDefault>
     std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
@@ -15657,7 +16181,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+    void getImageSparseMemoryRequirements2KHR( const vk::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderDefault>
     std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
@@ -15666,14 +16190,14 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d = Dispatch() ) const;
+    void getImageSubresourceLayout( vk::Image image, const vk::ImageSubresource* pSubresource, vk::SubresourceLayout* pLayout, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d = Dispatch() ) const;
+    vk::SubresourceLayout getImageSubresourceLayout( vk::Image image, const ImageSubresource & subresource, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX* pInfo, Dispatch const &d = Dispatch() ) const;
+    uint32_t getImageViewHandleNVX( const vk::ImageViewHandleInfoNVX* pInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info, Dispatch const &d = Dispatch() ) const;
@@ -15681,7 +16205,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = Dispatch() ) const;
+    Result getMemoryAndroidHardwareBufferANDROID( const vk::MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<struct AHardwareBuffer*>::type getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d = Dispatch() ) const;
@@ -15689,29 +16213,29 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+    Result getMemoryFdKHR( const vk::MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = Dispatch() ) const;
+    Result getMemoryFdPropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, vk::MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = Dispatch() ) const;
+    Result getMemoryHostPointerPropertiesEXT( vk::ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, vk::MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( vk::ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+    Result getMemoryWin32HandleKHR( const vk::MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
@@ -15720,77 +16244,104 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+    Result getMemoryWin32HandleNV( vk::DeviceMemory memory, vk::ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<HANDLE>::type getMemoryWin32HandleNV( vk::DeviceMemory memory, vk::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = Dispatch() ) const;
+    Result getMemoryWin32HandlePropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, vk::MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = Dispatch() ) const;
+    Result getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, vk::PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, PerformanceValueINTEL* pValue, Dispatch const &d = Dispatch() ) const;
+    Result getPerformanceParameterINTEL( vk::PerformanceParameterTypeINTEL parameter, vk::PerformanceValueINTEL* pValue, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<PerformanceValueINTEL>::type getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::PerformanceValueINTEL>::type getPerformanceParameterINTEL( vk::PerformanceParameterTypeINTEL parameter, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+    Result getPipelineCacheData( vk::PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( vk::PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( vk::PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderDefault>
+    Result getPipelineExecutableInternalRepresentationsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, vk::PipelineExecutableInternalRepresentationKHR* pInternalRepresentations, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PipelineExecutableInternalRepresentationKHR>, typename Dispatch = DispatchLoaderDefault>
+    typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,Allocator>>::type getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<PipelineExecutableInternalRepresentationKHR>, typename Dispatch = DispatchLoaderDefault>
+    typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,Allocator>>::type getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+    Result getPipelineExecutablePropertiesKHR( const vk::PipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, vk::PipelineExecutablePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PipelineExecutablePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
+    typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR,Allocator>>::type getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<PipelineExecutablePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
+    typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR,Allocator>>::type getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderDefault>
+    Result getPipelineExecutableStatisticsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, vk::PipelineExecutableStatisticKHR* pStatistics, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PipelineExecutableStatisticKHR>, typename Dispatch = DispatchLoaderDefault>
+    typename ResultValueType<std::vector<PipelineExecutableStatisticKHR,Allocator>>::type getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<PipelineExecutableStatisticKHR>, typename Dispatch = DispatchLoaderDefault>
+    typename ResultValueType<std::vector<PipelineExecutableStatisticKHR,Allocator>>::type getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderDefault>
+    Result getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename T, typename Dispatch = DispatchLoaderDefault>
-    Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+    Result getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+    Result getRayTracingShaderGroupHandlesNV( vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename T, typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = Dispatch() ) const;
+    Result getRefreshCycleDurationGOOGLE( vk::SwapchainKHR swapchain, vk::RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( vk::SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d = Dispatch() ) const;
+    void getRenderAreaGranularity( vk::RenderPass renderPass, vk::Extent2D* pGranularity, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Extent2D getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d = Dispatch() ) const;
+    vk::Extent2D getRenderAreaGranularity( vk::RenderPass renderPass, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+    Result getSemaphoreFdKHR( const vk::SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
@@ -15798,7 +16349,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+    Result getSemaphoreWin32HandleKHR( const vk::SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
@@ -15806,44 +16357,44 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = Dispatch() ) const;
+    Result getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = Dispatch() ) const;
+    Result getSwapchainCounterEXT( vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<uint64_t>::type getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<uint64_t>::type getSwapchainCounterEXT( vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d = Dispatch() ) const;
+    Result getSwapchainImagesKHR( vk::SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, vk::Image* pSwapchainImages, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( vk::SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( vk::SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    Result getSwapchainStatusKHR( vk::SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+    Result getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = Dispatch() ) const;
+    Result importFenceFdKHR( const vk::ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d = Dispatch() ) const;
@@ -15851,7 +16402,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+    Result importFenceWin32HandleKHR( const vk::ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
@@ -15859,7 +16410,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
+    Result importSemaphoreFdKHR( const vk::ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
@@ -15867,7 +16418,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+    Result importSemaphoreWin32HandleKHR( const vk::ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
@@ -15875,122 +16426,122 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d = Dispatch() ) const;
+    Result initializePerformanceApiINTEL( const vk::InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
+    Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const vk::MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const vk::MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d = Dispatch() ) const;
+    Result mapMemory( vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags, void** ppData, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void*>::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags(), Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void*>::type mapMemory( vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags = MemoryMapFlags(), Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d = Dispatch() ) const;
+    Result mergePipelineCaches( vk::PipelineCache dstCache, uint32_t srcCacheCount, const vk::PipelineCache* pSrcCaches, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type mergePipelineCaches( vk::PipelineCache dstCache, ArrayProxy<const vk::PipelineCache> srcCaches, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d = Dispatch() ) const;
+    Result mergeValidationCachesEXT( vk::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const vk::ValidationCacheEXT* pSrcCaches, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type mergeValidationCachesEXT( vk::ValidationCacheEXT dstCache, ArrayProxy<const vk::ValidationCacheEXT> srcCaches, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+    Result registerEventEXT( const vk::DeviceEventInfoEXT* pDeviceEventInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+    Result registerDisplayEventEXT( vk::DisplayKHR display, const vk::DisplayEventInfoEXT* pDisplayEventInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Fence>::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Fence>::type registerDisplayEventEXT( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
+    Result registerObjectsNVX( vk::ObjectTableNVX objectTable, uint32_t objectCount, const vk::ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type registerObjectsNVX( vk::ObjectTableNVX objectTable, ArrayProxy<const vk::ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    Result releaseFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type releaseFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
+    Result releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
+    Result resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
+    Result resetDescriptorPool( vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type resetDescriptorPool( vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
+    Result resetEvent( vk::Event event, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type resetEvent( vk::Event event, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d = Dispatch() ) const;
+    Result resetFences( uint32_t fenceCount, const vk::Fence* pFences, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type resetFences( ArrayProxy<const Fence> fences, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type resetFences( ArrayProxy<const vk::Fence> fences, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
+    void resetQueryPoolEXT( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
+    Result setDebugUtilsObjectNameEXT( const vk::DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
+    Result setDebugUtilsObjectTagEXT( const vk::DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     ResultValueType<void>::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
@@ -15998,59 +16549,59 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result setEvent( Event event, Dispatch const &d = Dispatch() ) const;
+    Result setEvent( vk::Event event, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type setEvent( Event event, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type setEvent( vk::Event event, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d = Dispatch() ) const;
+    void setHdrMetadataEXT( uint32_t swapchainCount, const vk::SwapchainKHR* pSwapchains, const vk::HdrMetadataEXT* pMetadata, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d = Dispatch() ) const;
+    void setHdrMetadataEXT( ArrayProxy<const vk::SwapchainKHR> swapchains, ArrayProxy<const vk::HdrMetadataEXT> metadata, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d = Dispatch() ) const;
+    void setLocalDimmingAMD( vk::SwapchainKHR swapChain, vk::Bool32 localDimmingEnable, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
+    void trimCommandPool( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
+    void trimCommandPoolKHR( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
     void uninitializePerformanceApiINTEL(Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
+    void unmapMemory( vk::DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
+    Result unregisterObjectsNVX( vk::ObjectTableNVX objectTable, uint32_t objectCount, const vk::ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type unregisterObjectsNVX( vk::ObjectTableNVX objectTable, ArrayProxy<const vk::ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
+    void updateDescriptorSetWithTemplate( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
+    void updateDescriptorSetWithTemplateKHR( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = Dispatch() ) const;
+    void updateDescriptorSets( uint32_t descriptorWriteCount, const vk::WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const vk::CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d = Dispatch() ) const;
+    void updateDescriptorSets( ArrayProxy<const vk::WriteDescriptorSet> descriptorWrites, ArrayProxy<const vk::CopyDescriptorSet> descriptorCopies, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
+    Result waitForFences( uint32_t fenceCount, const vk::Fence* pFences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
+    Result waitForFences( ArrayProxy<const vk::Fence> fences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
@@ -16073,11 +16624,19 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<ObjectType::eDevice>
+  {
+    using type = Device;
+  };
+
   class DisplayModeKHR
   {
   public:
     using CType = VkDisplayModeKHR;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR;
+
   public:
     VULKAN_HPP_CONSTEXPR DisplayModeKHR()
       : m_displayModeKHR(VK_NULL_HANDLE)
@@ -16140,6 +16699,12 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<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, DispatchLoaderDefault>;
@@ -16150,6 +16715,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkPhysicalDevice;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice;
+
   public:
     VULKAN_HPP_CONSTEXPR PhysicalDevice()
       : m_physicalDevice(VK_NULL_HANDLE)
@@ -16194,18 +16761,18 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     template<typename Dispatch = DispatchLoaderDefault>
-    Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+    Result acquireXlibDisplayEXT( Display* dpy, vk::DisplayKHR display, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Display>::type acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<Display>::type acquireXlibDisplayEXT( vk::DisplayKHR display, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d = Dispatch() ) const;
+    Result createDevice( const vk::DeviceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Device* pDevice, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<Device,Dispatch>>::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16213,14 +16780,14 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d = Dispatch() ) const;
+    Result createDisplayModeKHR( vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DisplayModeKHR* pMode, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DisplayModeKHR>::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DisplayModeKHR>::type createDisplayModeKHR( vk::DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, vk::ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16229,7 +16796,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, vk::LayerProperties* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Dispatch const &d = Dispatch() ) const;
@@ -16238,39 +16805,39 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayModeProperties2KHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModeProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( vk::DisplayKHR display, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( vk::DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayModePropertiesKHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( vk::DisplayKHR display, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( vk::DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayPlaneCapabilities2KHR( const vk::DisplayPlaneInfo2KHR* pDisplayPlaneInfo, vk::DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayPlaneCapabilitiesKHR( vk::DisplayModeKHR mode, uint32_t planeIndex, vk::DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( vk::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, vk::DisplayKHR* pDisplays, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
@@ -16279,7 +16846,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d = Dispatch() ) const;
+    Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, vk::TimeDomainEXT* pTimeDomains, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Dispatch const &d = Dispatch() ) const;
@@ -16288,7 +16855,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, vk::CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<CooperativeMatrixPropertiesNV>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV,Allocator>>::type getCooperativeMatrixPropertiesNV(Dispatch const &d = Dispatch() ) const;
@@ -16297,7 +16864,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, vk::DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Dispatch const &d = Dispatch() ) const;
@@ -16306,7 +16873,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, vk::DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Dispatch const &d = Dispatch() ) const;
@@ -16315,7 +16882,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayProperties2KHR( uint32_t* pPropertyCount, vk::DisplayProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Dispatch const &d = Dispatch() ) const;
@@ -16324,7 +16891,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+    Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, vk::DisplayPropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Dispatch const &d = Dispatch() ) const;
@@ -16333,204 +16900,204 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
+    void getExternalBufferProperties( const vk::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, vk::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
+    vk::ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
+    void getExternalBufferPropertiesKHR( const vk::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, vk::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
+    vk::ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
+    void getExternalFenceProperties( const vk::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, vk::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
+    vk::ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
+    void getExternalFencePropertiesKHR( const vk::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, vk::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
+    vk::ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+    Result getExternalImageFormatPropertiesNV( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, vk::ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
+    void getExternalSemaphoreProperties( const vk::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
+    vk::ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
+    void getExternalSemaphorePropertiesKHR( const vk::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
+    vk::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d = Dispatch() ) const;
+    void getFeatures( vk::PhysicalDeviceFeatures* pFeatures, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceFeatures getFeatures(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceFeatures getFeatures(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
+    void getFeatures2( vk::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getFeatures2(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
+    void getFeatures2KHR( vk::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+    void getFormatProperties( vk::Format format, vk::FormatProperties* pFormatProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    FormatProperties getFormatProperties( Format format, Dispatch const &d = Dispatch() ) const;
+    vk::FormatProperties getFormatProperties( vk::Format format, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+    void getFormatProperties2( vk::Format format, vk::FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    FormatProperties2 getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
+    vk::FormatProperties2 getFormatProperties2( vk::Format format, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
-    StructureChain<X, Y, Z...> getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
+    StructureChain<X, Y, Z...> getFormatProperties2( vk::Format format, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+    void getFormatProperties2KHR( vk::Format format, vk::FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    FormatProperties2 getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
+    vk::FormatProperties2 getFormatProperties2KHR( vk::Format format, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
-    StructureChain<X, Y, Z...> getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
+    StructureChain<X, Y, Z...> getFormatProperties2KHR( vk::Format format, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = Dispatch() ) const;
+    void getGeneratedCommandsPropertiesNVX( vk::DeviceGeneratedCommandsFeaturesNVX* pFeatures, vk::DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d = Dispatch() ) const;
+    vk::DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+    Result getImageFormatProperties( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ImageFormatProperties* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ImageFormatProperties>::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ImageFormatProperties>::type getImageFormatProperties( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+    Result getImageFormatProperties2( const vk::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, vk::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ImageFormatProperties2>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+    Result getImageFormatProperties2KHR( const vk::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, vk::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::ImageFormatProperties2>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+    void getMemoryProperties( vk::PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+    void getMemoryProperties2( vk::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+    void getMemoryProperties2KHR( vk::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = Dispatch() ) const;
+    void getMultisamplePropertiesEXT( vk::SampleCountFlagBits samples, vk::MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d = Dispatch() ) const;
+    vk::MultisamplePropertiesEXT getMultisamplePropertiesEXT( vk::SampleCountFlagBits samples, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d = Dispatch() ) const;
+    Result getPresentRectanglesKHR( vk::SurfaceKHR surface, uint32_t* pRectCount, vk::Rect2D* pRects, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( vk::SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+    void getProperties( vk::PhysicalDeviceProperties* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+    void getProperties2( vk::PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getProperties2(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+    void getProperties2KHR( vk::PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const;
+    vk::PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     StructureChain<X, Y, Z...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+    void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderDefault>
     std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Dispatch const &d = Dispatch() ) const;
@@ -16539,7 +17106,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+    void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderDefault>
     std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const;
@@ -16552,7 +17119,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+    void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderDefault>
     std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const;
@@ -16565,16 +17132,16 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+    void getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, uint32_t* pPropertyCount, vk::SparseImageFormatProperties* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderDefault>
-    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d = Dispatch() ) const;
+    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderDefault>
-    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+    void getSparseImageFormatProperties2( const vk::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, vk::SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderDefault>
     std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
@@ -16583,7 +17150,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+    void getSparseImageFormatProperties2KHR( const vk::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, vk::SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderDefault>
     std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
@@ -16592,7 +17159,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d = Dispatch() ) const;
+    Result getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, vk::FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<FramebufferMixedSamplesCombinationNV>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV,Allocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV(Dispatch const &d = Dispatch() ) const;
@@ -16601,30 +17168,30 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+    Result getSurfaceCapabilities2EXT( vk::SurfaceKHR surface, vk::SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( vk::SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+    Result getSurfaceCapabilities2KHR( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, vk::SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
     template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+    Result getSurfaceCapabilitiesKHR( vk::SurfaceKHR surface, vk::SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( vk::SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
+    Result getSurfaceFormats2KHR( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, vk::SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
@@ -16633,17 +17200,17 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
+    Result getSurfaceFormatsKHR( vk::SurfaceKHR surface, uint32_t* pSurfaceFormatCount, vk::SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( vk::SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
+    Result getSurfacePresentModes2EXT( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, vk::PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
@@ -16653,19 +17220,19 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
+    Result getSurfacePresentModesKHR( vk::SurfaceKHR surface, uint32_t* pPresentModeCount, vk::PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( vk::SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
     template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderDefault>
-    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const;
+    Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, vk::SurfaceKHR surface, vk::Bool32* pSupported, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, vk::SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
@@ -16702,19 +17269,19 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     template<typename Dispatch = DispatchLoaderDefault>
-    Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d = Dispatch() ) const;
+    Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, vk::DisplayKHR* pDisplay, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    Result releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+    Result releaseDisplayEXT( vk::DisplayKHR display, Dispatch const &d = Dispatch() ) const;
 #else
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<void>::type releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<void>::type releaseDisplayEXT( vk::DisplayKHR display, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
@@ -16737,6 +17304,12 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<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>; };
@@ -16752,6 +17325,8 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using CType = VkInstance;
 
+    static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance;
+
   public:
     VULKAN_HPP_CONSTEXPR Instance()
       : m_instance(VK_NULL_HANDLE)
@@ -16796,10 +17371,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createAndroidSurfaceKHR( const vk::AndroidSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16808,10 +17383,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const;
+    Result createDebugReportCallbackEXT( const vk::DebugReportCallbackCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16819,10 +17394,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = Dispatch() ) const;
+    Result createDebugUtilsMessengerEXT( const vk::DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16830,10 +17405,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createDisplayPlaneSurfaceKHR( const vk::DisplaySurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16841,10 +17416,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createHeadlessSurfaceEXT( const vk::HeadlessSurfaceCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16853,10 +17428,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_IOS_MVK
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createIOSSurfaceMVK( const vk::IOSSurfaceCreateInfoMVK* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16866,10 +17441,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_FUCHSIA
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createImagePipeSurfaceFUCHSIA( const vk::ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16879,10 +17454,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_MACOS_MVK
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createMacOSSurfaceMVK( const vk::MacOSSurfaceCreateInfoMVK* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16892,10 +17467,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_METAL_EXT
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createMetalSurfaceEXT( const vk::MetalSurfaceCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16905,10 +17480,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_GGP
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createStreamDescriptorSurfaceGGP( const vk::StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16918,10 +17493,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_VI_NN
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createViSurfaceNN( const vk::ViSurfaceCreateInfoNN* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16931,10 +17506,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createWaylandSurfaceKHR( const vk::WaylandSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16944,10 +17519,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createWin32SurfaceKHR( const vk::Win32SurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16957,10 +17532,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createXcbSurfaceKHR( const vk::XcbSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16970,10 +17545,10 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
     template<typename Dispatch = DispatchLoaderDefault>
-    Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+    Result createXlibSurfaceKHR( const vk::XlibSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    ResultValueType<SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    ResultValueType<vk::SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
     template<typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
@@ -16982,63 +17557,63 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = Dispatch() ) const;
+    void debugReportMessageEXT( vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = Dispatch() ) const;
+    void debugReportMessageEXT( vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyDebugReportCallbackEXT( vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyDebugReportCallbackEXT( vk::DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroyDebugUtilsMessengerEXT( vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroyDebugUtilsMessengerEXT( vk::DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
     void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroySurfaceKHR( vk::SurfaceKHR surface, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroySurfaceKHR( vk::SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::SurfaceKHR surface, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    void destroy( vk::SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
+    Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Dispatch const &d = Dispatch() ) const;
@@ -17047,7 +17622,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
+    Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d = Dispatch() ) const;
@@ -17056,7 +17631,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d = Dispatch() ) const;
+    Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, vk::PhysicalDevice* pPhysicalDevices, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderDefault>
     typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Dispatch const &d = Dispatch() ) const;
@@ -17072,10 +17647,10 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = DispatchLoaderDefault>
-    void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = Dispatch() ) const;
+    void submitDebugUtilsMessageEXT( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const vk::DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = Dispatch() ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = DispatchLoaderDefault>
-    void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = Dispatch() ) const;
+    void submitDebugUtilsMessageEXT( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = Dispatch() ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const
@@ -17098,16 +17673,22 @@ namespace VULKAN_HPP_NAMESPACE
   };
   static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
 
+  template <>
+  struct cpp_type<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, DispatchLoaderDefault>;
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 
   template<typename Dispatch = DispatchLoaderDefault>
-  Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d = Dispatch() );
+  Result createInstance( const vk::InstanceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Instance* pInstance, Dispatch const &d = Dispatch() );
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch = DispatchLoaderDefault>
-  ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
+  ResultValueType<vk::Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template<typename Dispatch = DispatchLoaderDefault>
   typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
@@ -17115,7 +17696,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch = DispatchLoaderDefault>
-  Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() );
+  Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, vk::ExtensionProperties* pProperties, Dispatch const &d = Dispatch() );
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderDefault>
   typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() );
@@ -17124,7 +17705,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch = DispatchLoaderDefault>
-  Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() );
+  Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, vk::LayerProperties* pProperties, Dispatch const &d = Dispatch() );
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderDefault>
   typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d = Dispatch() );
@@ -17139,36 +17720,83 @@ namespace VULKAN_HPP_NAMESPACE
   ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d = Dispatch() );
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  struct GeometryTrianglesNV
+  namespace layout
+  {
+    struct GeometryTrianglesNV
+    {
+    protected:
+      GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(),
+                           vk::DeviceSize vertexOffset_ = 0,
+                           uint32_t vertexCount_ = 0,
+                           vk::DeviceSize vertexStride_ = 0,
+                           vk::Format vertexFormat_ = vk::Format::eUndefined,
+                           vk::Buffer indexData_ = vk::Buffer(),
+                           vk::DeviceSize indexOffset_ = 0,
+                           uint32_t indexCount_ = 0,
+                           vk::IndexType indexType_ = vk::IndexType::eUint16,
+                           vk::Buffer transformData_ = vk::Buffer(),
+                           vk::DeviceSize transformOffset_ = 0 )
+        : vertexData( vertexData_ )
+        , vertexOffset( vertexOffset_ )
+        , vertexCount( vertexCount_ )
+        , vertexStride( vertexStride_ )
+        , vertexFormat( vertexFormat_ )
+        , indexData( indexData_ )
+        , indexOffset( indexOffset_ )
+        , indexCount( indexCount_ )
+        , indexType( indexType_ )
+        , transformData( transformData_ )
+        , transformOffset( transformOffset_ )
+      {}
+
+      GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs )
+      {
+        *reinterpret_cast<VkGeometryTrianglesNV*>(this) = rhs;
+      }
+
+      GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs )
+      {
+        *reinterpret_cast<VkGeometryTrianglesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eGeometryTrianglesNV;
+      const void* pNext = nullptr;
+      vk::Buffer vertexData;
+      vk::DeviceSize vertexOffset;
+      uint32_t vertexCount;
+      vk::DeviceSize vertexStride;
+      vk::Format vertexFormat;
+      vk::Buffer indexData;
+      vk::DeviceSize indexOffset;
+      uint32_t indexCount;
+      vk::IndexType indexType;
+      vk::Buffer transformData;
+      vk::DeviceSize transformOffset;
+    };
+    static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct GeometryTrianglesNV : public layout::GeometryTrianglesNV
   {
-    GeometryTrianglesNV( Buffer vertexData_ = Buffer(),
-                         DeviceSize vertexOffset_ = 0,
+    GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(),
+                         vk::DeviceSize vertexOffset_ = 0,
                          uint32_t vertexCount_ = 0,
-                         DeviceSize vertexStride_ = 0,
-                         Format vertexFormat_ = Format::eUndefined,
-                         Buffer indexData_ = Buffer(),
-                         DeviceSize indexOffset_ = 0,
+                         vk::DeviceSize vertexStride_ = 0,
+                         vk::Format vertexFormat_ = vk::Format::eUndefined,
+                         vk::Buffer indexData_ = vk::Buffer(),
+                         vk::DeviceSize indexOffset_ = 0,
                          uint32_t indexCount_ = 0,
-                         IndexType indexType_ = IndexType::eUint16,
-                         Buffer transformData_ = Buffer(),
-                         DeviceSize transformOffset_ = 0 )
-      : vertexData( vertexData_ )
-      , vertexOffset( vertexOffset_ )
-      , vertexCount( vertexCount_ )
-      , vertexStride( vertexStride_ )
-      , vertexFormat( vertexFormat_ )
-      , indexData( indexData_ )
-      , indexOffset( indexOffset_ )
-      , indexCount( indexCount_ )
-      , indexType( indexType_ )
-      , transformData( transformData_ )
-      , transformOffset( transformOffset_ )
+                         vk::IndexType indexType_ = vk::IndexType::eUint16,
+                         vk::Buffer transformData_ = vk::Buffer(),
+                         vk::DeviceSize transformOffset_ = 0 )
+      : layout::GeometryTrianglesNV( vertexData_, vertexOffset_, vertexCount_, vertexStride_, vertexFormat_, indexData_, indexOffset_, indexCount_, indexType_, transformData_, transformOffset_ )
     {}
 
     GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs )
-    {
-      *reinterpret_cast<VkGeometryTrianglesNV*>(this) = rhs;
-    }
+      : layout::GeometryTrianglesNV( rhs )
+    {}
 
     GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs )
     {
@@ -17182,13 +17810,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryTrianglesNV & setVertexData( Buffer vertexData_ )
+    GeometryTrianglesNV & setVertexData( vk::Buffer vertexData_ )
     {
       vertexData = vertexData_;
       return *this;
     }
 
-    GeometryTrianglesNV & setVertexOffset( DeviceSize vertexOffset_ )
+    GeometryTrianglesNV & setVertexOffset( vk::DeviceSize vertexOffset_ )
     {
       vertexOffset = vertexOffset_;
       return *this;
@@ -17200,25 +17828,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryTrianglesNV & setVertexStride( DeviceSize vertexStride_ )
+    GeometryTrianglesNV & setVertexStride( vk::DeviceSize vertexStride_ )
     {
       vertexStride = vertexStride_;
       return *this;
     }
 
-    GeometryTrianglesNV & setVertexFormat( Format vertexFormat_ )
+    GeometryTrianglesNV & setVertexFormat( vk::Format vertexFormat_ )
     {
       vertexFormat = vertexFormat_;
       return *this;
     }
 
-    GeometryTrianglesNV & setIndexData( Buffer indexData_ )
+    GeometryTrianglesNV & setIndexData( vk::Buffer indexData_ )
     {
       indexData = indexData_;
       return *this;
     }
 
-    GeometryTrianglesNV & setIndexOffset( DeviceSize indexOffset_ )
+    GeometryTrianglesNV & setIndexOffset( vk::DeviceSize indexOffset_ )
     {
       indexOffset = indexOffset_;
       return *this;
@@ -17230,19 +17858,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryTrianglesNV & setIndexType( IndexType indexType_ )
+    GeometryTrianglesNV & setIndexType( vk::IndexType indexType_ )
     {
       indexType = indexType_;
       return *this;
     }
 
-    GeometryTrianglesNV & setTransformData( Buffer transformData_ )
+    GeometryTrianglesNV & setTransformData( vk::Buffer transformData_ )
     {
       transformData = transformData_;
       return *this;
     }
 
-    GeometryTrianglesNV & setTransformOffset( DeviceSize transformOffset_ )
+    GeometryTrianglesNV & setTransformOffset( vk::DeviceSize transformOffset_ )
     {
       transformOffset = transformOffset_;
       return *this;
@@ -17281,40 +17909,60 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eGeometryTrianglesNV;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer vertexData;
-    DeviceSize vertexOffset;
-    uint32_t vertexCount;
-    DeviceSize vertexStride;
-    Format vertexFormat;
-    Buffer indexData;
-    DeviceSize indexOffset;
-    uint32_t indexCount;
-    IndexType indexType;
-    Buffer transformData;
-    DeviceSize transformOffset;
+    using layout::GeometryTrianglesNV::sType;
   };
   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!" );
 
-  struct GeometryAABBNV
+  namespace layout
   {
-    GeometryAABBNV( Buffer aabbData_ = Buffer(),
+    struct GeometryAABBNV
+    {
+    protected:
+      GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(),
+                      uint32_t numAABBs_ = 0,
+                      uint32_t stride_ = 0,
+                      vk::DeviceSize offset_ = 0 )
+        : aabbData( aabbData_ )
+        , numAABBs( numAABBs_ )
+        , stride( stride_ )
+        , offset( offset_ )
+      {}
+
+      GeometryAABBNV( VkGeometryAABBNV const & rhs )
+      {
+        *reinterpret_cast<VkGeometryAABBNV*>(this) = rhs;
+      }
+
+      GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs )
+      {
+        *reinterpret_cast<VkGeometryAABBNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eGeometryAabbNV;
+      const void* pNext = nullptr;
+      vk::Buffer aabbData;
+      uint32_t numAABBs;
+      uint32_t stride;
+      vk::DeviceSize offset;
+    };
+    static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct GeometryAABBNV : public layout::GeometryAABBNV
+  {
+    GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(),
                     uint32_t numAABBs_ = 0,
                     uint32_t stride_ = 0,
-                    DeviceSize offset_ = 0 )
-      : aabbData( aabbData_ )
-      , numAABBs( numAABBs_ )
-      , stride( stride_ )
-      , offset( offset_ )
+                    vk::DeviceSize offset_ = 0 )
+      : layout::GeometryAABBNV( aabbData_, numAABBs_, stride_, offset_ )
     {}
 
     GeometryAABBNV( VkGeometryAABBNV const & rhs )
-    {
-      *reinterpret_cast<VkGeometryAABBNV*>(this) = rhs;
-    }
+      : layout::GeometryAABBNV( rhs )
+    {}
 
     GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs )
     {
@@ -17328,7 +17976,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryAABBNV & setAabbData( Buffer aabbData_ )
+    GeometryAABBNV & setAabbData( vk::Buffer aabbData_ )
     {
       aabbData = aabbData_;
       return *this;
@@ -17346,7 +17994,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryAABBNV & setOffset( DeviceSize offset_ )
+    GeometryAABBNV & setOffset( vk::DeviceSize offset_ )
     {
       offset = offset_;
       return *this;
@@ -17378,23 +18026,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eGeometryAabbNV;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer aabbData;
-    uint32_t numAABBs;
-    uint32_t stride;
-    DeviceSize offset;
+    using layout::GeometryAABBNV::sType;
   };
   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!" );
 
   struct GeometryDataNV
   {
-    GeometryDataNV( GeometryTrianglesNV triangles_ = GeometryTrianglesNV(),
-                    GeometryAABBNV aabbs_ = GeometryAABBNV() )
-      : triangles( triangles_ )
-      , aabbs( aabbs_ )
+    GeometryDataNV( vk::GeometryTrianglesNV triangles_ = vk::GeometryTrianglesNV(),
+                    vk::GeometryAABBNV aabbs_ = vk::GeometryAABBNV() )
+        : triangles( triangles_ )
+        , aabbs( aabbs_ )
     {}
 
     GeometryDataNV( VkGeometryDataNV const & rhs )
@@ -17408,13 +18050,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryDataNV & setTriangles( GeometryTrianglesNV triangles_ )
+    GeometryDataNV & setTriangles( vk::GeometryTrianglesNV triangles_ )
     {
       triangles = triangles_;
       return *this;
     }
 
-    GeometryDataNV & setAabbs( GeometryAABBNV aabbs_ )
+    GeometryDataNV & setAabbs( vk::GeometryAABBNV aabbs_ )
     {
       aabbs = aabbs_;
       return *this;
@@ -17441,25 +18083,58 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    GeometryTrianglesNV triangles;
-    GeometryAABBNV aabbs;
+  public:
+    vk::GeometryTrianglesNV triangles;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct GeometryNV
+    {
+    protected:
+      GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles,
+                  vk::GeometryDataNV geometry_ = vk::GeometryDataNV(),
+                  vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() )
+        : geometryType( geometryType_ )
+        , geometry( geometry_ )
+        , flags( flags_ )
+      {}
+
+      GeometryNV( VkGeometryNV const & rhs )
+      {
+        *reinterpret_cast<VkGeometryNV*>(this) = rhs;
+      }
+
+      GeometryNV& operator=( VkGeometryNV const & rhs )
+      {
+        *reinterpret_cast<VkGeometryNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct GeometryNV
+    public:
+      vk::StructureType sType = StructureType::eGeometryNV;
+      const void* pNext = nullptr;
+      vk::GeometryTypeNV geometryType;
+      vk::GeometryDataNV geometry;
+      vk::GeometryFlagsNV flags;
+    };
+    static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct GeometryNV : public layout::GeometryNV
   {
-    GeometryNV( GeometryTypeNV geometryType_ = GeometryTypeNV::eTriangles,
-                GeometryDataNV geometry_ = GeometryDataNV(),
-                GeometryFlagsNV flags_ = GeometryFlagsNV() )
-      : geometryType( geometryType_ )
-      , geometry( geometry_ )
-      , flags( flags_ )
+    GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles,
+                vk::GeometryDataNV geometry_ = vk::GeometryDataNV(),
+                vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() )
+      : layout::GeometryNV( geometryType_, geometry_, flags_ )
     {}
 
     GeometryNV( VkGeometryNV const & rhs )
-    {
-      *reinterpret_cast<VkGeometryNV*>(this) = rhs;
-    }
+      : layout::GeometryNV( rhs )
+    {}
 
     GeometryNV& operator=( VkGeometryNV const & rhs )
     {
@@ -17473,19 +18148,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GeometryNV & setGeometryType( GeometryTypeNV geometryType_ )
+    GeometryNV & setGeometryType( vk::GeometryTypeNV geometryType_ )
     {
       geometryType = geometryType_;
       return *this;
     }
 
-    GeometryNV & setGeometry( GeometryDataNV geometry_ )
+    GeometryNV & setGeometry( vk::GeometryDataNV geometry_ )
     {
       geometry = geometry_;
       return *this;
     }
 
-    GeometryNV & setFlags( GeometryFlagsNV flags_ )
+    GeometryNV & setFlags( vk::GeometryFlagsNV flags_ )
     {
       flags = flags_;
       return *this;
@@ -17516,34 +18191,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eGeometryNV;
-
-  public:
-    const void* pNext = nullptr;
-    GeometryTypeNV geometryType;
-    GeometryDataNV geometry;
-    GeometryFlagsNV flags;
+    using layout::GeometryNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct AccelerationStructureInfoNV
+    {
+    protected:
+      AccelerationStructureInfoNV( vk::AccelerationStructureTypeNV type_ = vk::AccelerationStructureTypeNV::eTopLevel,
+                                   vk::BuildAccelerationStructureFlagsNV flags_ = vk::BuildAccelerationStructureFlagsNV(),
+                                   uint32_t instanceCount_ = 0,
+                                   uint32_t geometryCount_ = 0,
+                                   const vk::GeometryNV* pGeometries_ = nullptr )
+        : type( type_ )
+        , flags( flags_ )
+        , instanceCount( instanceCount_ )
+        , geometryCount( geometryCount_ )
+        , pGeometries( pGeometries_ )
+      {}
+
+      AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkAccelerationStructureInfoNV*>(this) = rhs;
+      }
 
-  struct AccelerationStructureInfoNV
+      AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkAccelerationStructureInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eAccelerationStructureInfoNV;
+      const void* pNext = nullptr;
+      vk::AccelerationStructureTypeNV type;
+      vk::BuildAccelerationStructureFlagsNV flags;
+      uint32_t instanceCount;
+      uint32_t geometryCount;
+      const vk::GeometryNV* pGeometries;
+    };
+    static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AccelerationStructureInfoNV : public layout::AccelerationStructureInfoNV
   {
-    AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = AccelerationStructureTypeNV::eTopLevel,
-                                 BuildAccelerationStructureFlagsNV flags_ = BuildAccelerationStructureFlagsNV(),
+    AccelerationStructureInfoNV( vk::AccelerationStructureTypeNV type_ = vk::AccelerationStructureTypeNV::eTopLevel,
+                                 vk::BuildAccelerationStructureFlagsNV flags_ = vk::BuildAccelerationStructureFlagsNV(),
                                  uint32_t instanceCount_ = 0,
                                  uint32_t geometryCount_ = 0,
-                                 const GeometryNV* pGeometries_ = nullptr )
-      : type( type_ )
-      , flags( flags_ )
-      , instanceCount( instanceCount_ )
-      , geometryCount( geometryCount_ )
-      , pGeometries( pGeometries_ )
+                                 const vk::GeometryNV* pGeometries_ = nullptr )
+      : layout::AccelerationStructureInfoNV( type_, flags_, instanceCount_, geometryCount_, pGeometries_ )
     {}
 
     AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkAccelerationStructureInfoNV*>(this) = rhs;
-    }
+      : layout::AccelerationStructureInfoNV( rhs )
+    {}
 
     AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs )
     {
@@ -17557,13 +18262,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureInfoNV & setType( AccelerationStructureTypeNV type_ )
+    AccelerationStructureInfoNV & setType( vk::AccelerationStructureTypeNV type_ )
     {
       type = type_;
       return *this;
     }
 
-    AccelerationStructureInfoNV & setFlags( BuildAccelerationStructureFlagsNV flags_ )
+    AccelerationStructureInfoNV & setFlags( vk::BuildAccelerationStructureFlagsNV flags_ )
     {
       flags = flags_;
       return *this;
@@ -17581,7 +18286,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureInfoNV & setPGeometries( const GeometryNV* pGeometries_ )
+    AccelerationStructureInfoNV & setPGeometries( const vk::GeometryNV* pGeometries_ )
     {
       pGeometries = pGeometries_;
       return *this;
@@ -17614,30 +18319,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAccelerationStructureInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    AccelerationStructureTypeNV type;
-    BuildAccelerationStructureFlagsNV flags;
-    uint32_t instanceCount;
-    uint32_t geometryCount;
-    const GeometryNV* pGeometries;
+    using layout::AccelerationStructureInfoNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct AccelerationStructureCreateInfoNV
+    {
+    protected:
+      AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0,
+                                         vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() )
+        : compactedSize( compactedSize_ )
+        , info( info_ )
+      {}
+
+      AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this) = rhs;
+      }
+
+      AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct AccelerationStructureCreateInfoNV
+    public:
+      vk::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::DeviceSize compactedSize;
+      vk::AccelerationStructureInfoNV info;
+    };
+    static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AccelerationStructureCreateInfoNV : public layout::AccelerationStructureCreateInfoNV
   {
-    AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = 0,
-                                       AccelerationStructureInfoNV info_ = AccelerationStructureInfoNV() )
-      : compactedSize( compactedSize_ )
-      , info( info_ )
+    AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0,
+                                       vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() )
+      : layout::AccelerationStructureCreateInfoNV( compactedSize_, info_ )
     {}
 
     AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this) = rhs;
-    }
+      : layout::AccelerationStructureCreateInfoNV( rhs )
+    {}
 
     AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs )
     {
@@ -17651,13 +18378,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureCreateInfoNV & setCompactedSize( DeviceSize compactedSize_ )
+    AccelerationStructureCreateInfoNV & setCompactedSize( vk::DeviceSize compactedSize_ )
     {
       compactedSize = compactedSize_;
       return *this;
     }
 
-    AccelerationStructureCreateInfoNV & setInfo( AccelerationStructureInfoNV info_ )
+    AccelerationStructureCreateInfoNV & setInfo( vk::AccelerationStructureInfoNV info_ )
     {
       info = info_;
       return *this;
@@ -17687,27 +18414,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceSize compactedSize;
-    AccelerationStructureInfoNV info;
+    using layout::AccelerationStructureCreateInfoNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct AccelerationStructureMemoryRequirementsInfoNV
+    {
+    protected:
+      AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject,
+                                                     vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() )
+        : type( type_ )
+        , accelerationStructure( accelerationStructure_ )
+      {}
+
+      AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this) = rhs;
+      }
+
+      AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
+      const void* pNext = nullptr;
+      vk::AccelerationStructureMemoryRequirementsTypeNV type;
+      vk::AccelerationStructureNV accelerationStructure;
+    };
+    static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "layout struct and wrapper have different size!" );
+  }
 
-  struct AccelerationStructureMemoryRequirementsInfoNV
+  struct AccelerationStructureMemoryRequirementsInfoNV : public layout::AccelerationStructureMemoryRequirementsInfoNV
   {
-    AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject,
-                                                   AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV() )
-      : type( type_ )
-      , accelerationStructure( accelerationStructure_ )
+    AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject,
+                                                   vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() )
+      : layout::AccelerationStructureMemoryRequirementsInfoNV( type_, accelerationStructure_ )
     {}
 
     AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this) = rhs;
-    }
+      : layout::AccelerationStructureMemoryRequirementsInfoNV( rhs )
+    {}
 
     AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
     {
@@ -17721,13 +18473,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AccelerationStructureMemoryRequirementsInfoNV & setType( AccelerationStructureMemoryRequirementsTypeNV type_ )
+    AccelerationStructureMemoryRequirementsInfoNV & setType( vk::AccelerationStructureMemoryRequirementsTypeNV type_ )
     {
       type = type_;
       return *this;
     }
 
-    AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
+    AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( vk::AccelerationStructureNV accelerationStructure_ )
     {
       accelerationStructure = accelerationStructure_;
       return *this;
@@ -17757,33 +18509,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    AccelerationStructureMemoryRequirementsTypeNV type;
-    AccelerationStructureNV accelerationStructure;
+    using layout::AccelerationStructureMemoryRequirementsInfoNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct AcquireNextImageInfoKHR
+    {
+    protected:
+      AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
+                               uint64_t timeout_ = 0,
+                               vk::Semaphore semaphore_ = vk::Semaphore(),
+                               vk::Fence fence_ = vk::Fence(),
+                               uint32_t deviceMask_ = 0 )
+        : swapchain( swapchain_ )
+        , timeout( timeout_ )
+        , semaphore( semaphore_ )
+        , fence( fence_ )
+        , deviceMask( deviceMask_ )
+      {}
+
+      AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this) = rhs;
+      }
+
+      AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct AcquireNextImageInfoKHR
+    public:
+      vk::StructureType sType = StructureType::eAcquireNextImageInfoKHR;
+      const void* pNext = nullptr;
+      vk::SwapchainKHR swapchain;
+      uint64_t timeout;
+      vk::Semaphore semaphore;
+      vk::Fence fence;
+      uint32_t deviceMask;
+    };
+    static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AcquireNextImageInfoKHR : public layout::AcquireNextImageInfoKHR
   {
-    AcquireNextImageInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(),
+    AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
                              uint64_t timeout_ = 0,
-                             Semaphore semaphore_ = Semaphore(),
-                             Fence fence_ = Fence(),
+                             vk::Semaphore semaphore_ = vk::Semaphore(),
+                             vk::Fence fence_ = vk::Fence(),
                              uint32_t deviceMask_ = 0 )
-      : swapchain( swapchain_ )
-      , timeout( timeout_ )
-      , semaphore( semaphore_ )
-      , fence( fence_ )
-      , deviceMask( deviceMask_ )
+      : layout::AcquireNextImageInfoKHR( swapchain_, timeout_, semaphore_, fence_, deviceMask_ )
     {}
 
     AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this) = rhs;
-    }
+      : layout::AcquireNextImageInfoKHR( rhs )
+    {}
 
     AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs )
     {
@@ -17797,7 +18580,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AcquireNextImageInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+    AcquireNextImageInfoKHR & setSwapchain( vk::SwapchainKHR swapchain_ )
     {
       swapchain = swapchain_;
       return *this;
@@ -17809,13 +18592,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AcquireNextImageInfoKHR & setSemaphore( Semaphore semaphore_ )
+    AcquireNextImageInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
     {
       semaphore = semaphore_;
       return *this;
     }
 
-    AcquireNextImageInfoKHR & setFence( Fence fence_ )
+    AcquireNextImageInfoKHR & setFence( vk::Fence fence_ )
     {
       fence = fence_;
       return *this;
@@ -17854,17 +18637,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAcquireNextImageInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
-    uint64_t timeout;
-    Semaphore semaphore;
-    Fence fence;
-    uint32_t deviceMask;
+    using layout::AcquireNextImageInfoKHR::sType;
   };
   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!" );
 
   struct AllocationCallbacks
   {
@@ -17874,12 +18650,12 @@ namespace VULKAN_HPP_NAMESPACE
                          PFN_vkFreeFunction pfnFree_ = nullptr,
                          PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr,
                          PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
-      : pUserData( pUserData_ )
-      , pfnAllocation( pfnAllocation_ )
-      , pfnReallocation( pfnReallocation_ )
-      , pfnFree( pfnFree_ )
-      , pfnInternalAllocation( pfnInternalAllocation_ )
-      , pfnInternalFree( pfnInternalFree_ )
+        : pUserData( pUserData_ )
+        , pfnAllocation( pfnAllocation_ )
+        , pfnReallocation( pfnReallocation_ )
+        , pfnFree( pfnFree_ )
+        , pfnInternalAllocation( pfnInternalAllocation_ )
+        , pfnInternalFree( pfnInternalFree_ )
     {}
 
     AllocationCallbacks( VkAllocationCallbacks const & rhs )
@@ -17954,6 +18730,7 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     void* pUserData;
     PFN_vkAllocationFunction pfnAllocation;
     PFN_vkReallocationFunction pfnReallocation;
@@ -17962,17 +18739,18 @@ namespace VULKAN_HPP_NAMESPACE
     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
   {
-    ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle g_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle b_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle a_ = ComponentSwizzle::eIdentity )
-      : r( r_ )
-      , g( g_ )
-      , b( b_ )
-      , a( a_ )
+    ComponentMapping( vk::ComponentSwizzle r_ = vk::ComponentSwizzle::eIdentity,
+                      vk::ComponentSwizzle g_ = vk::ComponentSwizzle::eIdentity,
+                      vk::ComponentSwizzle b_ = vk::ComponentSwizzle::eIdentity,
+                      vk::ComponentSwizzle a_ = vk::ComponentSwizzle::eIdentity )
+        : r( r_ )
+        , g( g_ )
+        , b( b_ )
+        , a( a_ )
     {}
 
     ComponentMapping( VkComponentMapping const & rhs )
@@ -17986,25 +18764,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ComponentMapping & setR( ComponentSwizzle r_ )
+    ComponentMapping & setR( vk::ComponentSwizzle r_ )
     {
       r = r_;
       return *this;
     }
 
-    ComponentMapping & setG( ComponentSwizzle g_ )
+    ComponentMapping & setG( vk::ComponentSwizzle g_ )
     {
       g = g_;
       return *this;
     }
 
-    ComponentMapping & setB( ComponentSwizzle b_ )
+    ComponentMapping & setB( vk::ComponentSwizzle b_ )
     {
       b = b_;
       return *this;
     }
 
-    ComponentMapping & setA( ComponentSwizzle a_ )
+    ComponentMapping & setA( vk::ComponentSwizzle a_ )
     {
       a = a_;
       return *this;
@@ -18033,15 +18811,67 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ComponentSwizzle r;
-    ComponentSwizzle g;
-    ComponentSwizzle b;
-    ComponentSwizzle a;
+  public:
+    vk::ComponentSwizzle r;
+    vk::ComponentSwizzle g;
+    vk::ComponentSwizzle b;
+    vk::ComponentSwizzle a;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidHardwareBufferFormatPropertiesANDROID
+
+  namespace layout
+  {
+    struct AndroidHardwareBufferFormatPropertiesANDROID
+    {
+    protected:
+      AndroidHardwareBufferFormatPropertiesANDROID( vk::Format format_ = vk::Format::eUndefined,
+                                                    uint64_t externalFormat_ = 0,
+                                                    vk::FormatFeatureFlags formatFeatures_ = vk::FormatFeatureFlags(),
+                                                    vk::ComponentMapping samplerYcbcrConversionComponents_ = vk::ComponentMapping(),
+                                                    vk::SamplerYcbcrModelConversion suggestedYcbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity,
+                                                    vk::SamplerYcbcrRange suggestedYcbcrRange_ = vk::SamplerYcbcrRange::eItuFull,
+                                                    vk::ChromaLocation suggestedXChromaOffset_ = vk::ChromaLocation::eCositedEven,
+                                                    vk::ChromaLocation suggestedYChromaOffset_ = vk::ChromaLocation::eCositedEven )
+        : format( format_ )
+        , externalFormat( externalFormat_ )
+        , formatFeatures( formatFeatures_ )
+        , samplerYcbcrConversionComponents( samplerYcbcrConversionComponents_ )
+        , suggestedYcbcrModel( suggestedYcbcrModel_ )
+        , suggestedYcbcrRange( suggestedYcbcrRange_ )
+        , suggestedXChromaOffset( suggestedXChromaOffset_ )
+        , suggestedYChromaOffset( suggestedYChromaOffset_ )
+      {}
+
+      AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs )
+      {
+        *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this) = rhs;
+      }
+
+      AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs )
+      {
+        *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
+      void* pNext = nullptr;
+      vk::Format format;
+      uint64_t externalFormat;
+      vk::FormatFeatureFlags formatFeatures;
+      vk::ComponentMapping samplerYcbcrConversionComponents;
+      vk::SamplerYcbcrModelConversion suggestedYcbcrModel;
+      vk::SamplerYcbcrRange suggestedYcbcrRange;
+      vk::ChromaLocation suggestedXChromaOffset;
+      vk::ChromaLocation suggestedYChromaOffset;
+    };
+    static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AndroidHardwareBufferFormatPropertiesANDROID : public layout::AndroidHardwareBufferFormatPropertiesANDROID
   {
     operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const
     {
@@ -18073,24 +18903,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
-
-  public:
-    void* pNext = nullptr;
-    Format format;
-    uint64_t externalFormat;
-    FormatFeatureFlags formatFeatures;
-    ComponentMapping samplerYcbcrConversionComponents;
-    SamplerYcbcrModelConversion suggestedYcbcrModel;
-    SamplerYcbcrRange suggestedYcbcrRange;
-    ChromaLocation suggestedXChromaOffset;
-    ChromaLocation suggestedYChromaOffset;
+    using layout::AndroidHardwareBufferFormatPropertiesANDROID::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidHardwareBufferPropertiesANDROID
+
+  namespace layout
+  {
+    struct AndroidHardwareBufferPropertiesANDROID
+    {
+    protected:
+      AndroidHardwareBufferPropertiesANDROID( vk::DeviceSize allocationSize_ = 0,
+                                              uint32_t memoryTypeBits_ = 0 )
+        : allocationSize( allocationSize_ )
+        , memoryTypeBits( memoryTypeBits_ )
+      {}
+
+      AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs )
+      {
+        *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this) = rhs;
+      }
+
+      AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs )
+      {
+        *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
+      void* pNext = nullptr;
+      vk::DeviceSize allocationSize;
+      uint32_t memoryTypeBits;
+    };
+    static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AndroidHardwareBufferPropertiesANDROID : public layout::AndroidHardwareBufferPropertiesANDROID
   {
     operator VkAndroidHardwareBufferPropertiesANDROID const&() const
     {
@@ -18116,18 +18968,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
-
-  public:
-    void* pNext = nullptr;
-    DeviceSize allocationSize;
-    uint32_t memoryTypeBits;
+    using layout::AndroidHardwareBufferPropertiesANDROID::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidHardwareBufferUsageANDROID
+
+  namespace layout
+  {
+    struct AndroidHardwareBufferUsageANDROID
+    {
+    protected:
+      AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = 0 )
+        : androidHardwareBufferUsage( androidHardwareBufferUsage_ )
+      {}
+
+      AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs )
+      {
+        *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this) = rhs;
+      }
+
+      AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs )
+      {
+        *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID;
+      void* pNext = nullptr;
+      uint64_t androidHardwareBufferUsage;
+    };
+    static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AndroidHardwareBufferUsageANDROID : public layout::AndroidHardwareBufferUsageANDROID
   {
     operator VkAndroidHardwareBufferUsageANDROID const&() const
     {
@@ -18152,28 +19029,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID;
-
-  public:
-    void* pNext = nullptr;
-    uint64_t androidHardwareBufferUsage;
+    using layout::AndroidHardwareBufferUsageANDROID::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidSurfaceCreateInfoKHR
+
+  namespace layout
   {
-    AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(),
+    struct AndroidSurfaceCreateInfoKHR
+    {
+    protected:
+      AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(),
+                                   struct ANativeWindow* window_ = nullptr )
+        : flags( flags_ )
+        , window( window_ )
+      {}
+
+      AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this) = rhs;
+      }
+
+      AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::AndroidSurfaceCreateFlagsKHR flags;
+      struct ANativeWindow* window;
+    };
+    static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AndroidSurfaceCreateInfoKHR : public layout::AndroidSurfaceCreateInfoKHR
+  {
+    AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(),
                                  struct ANativeWindow* window_ = nullptr )
-      : flags( flags_ )
-      , window( window_ )
+      : layout::AndroidSurfaceCreateInfoKHR( flags_, window_ )
     {}
 
     AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::AndroidSurfaceCreateInfoKHR( rhs )
+    {}
 
     AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
     {
@@ -18187,7 +19091,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AndroidSurfaceCreateInfoKHR & setFlags( AndroidSurfaceCreateFlagsKHR flags_ )
+    AndroidSurfaceCreateInfoKHR & setFlags( vk::AndroidSurfaceCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
@@ -18223,34 +19127,65 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    AndroidSurfaceCreateFlagsKHR flags;
-    struct ANativeWindow* window;
+    using layout::AndroidSurfaceCreateInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  struct ApplicationInfo
+  namespace layout
+  {
+    struct ApplicationInfo
+    {
+    protected:
+      ApplicationInfo( const char* pApplicationName_ = nullptr,
+                       uint32_t applicationVersion_ = 0,
+                       const char* pEngineName_ = nullptr,
+                       uint32_t engineVersion_ = 0,
+                       uint32_t apiVersion_ = 0 )
+        : pApplicationName( pApplicationName_ )
+        , applicationVersion( applicationVersion_ )
+        , pEngineName( pEngineName_ )
+        , engineVersion( engineVersion_ )
+        , apiVersion( apiVersion_ )
+      {}
+
+      ApplicationInfo( VkApplicationInfo const & rhs )
+      {
+        *reinterpret_cast<VkApplicationInfo*>(this) = rhs;
+      }
+
+      ApplicationInfo& operator=( VkApplicationInfo const & rhs )
+      {
+        *reinterpret_cast<VkApplicationInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eApplicationInfo;
+      const void* pNext = nullptr;
+      const char* pApplicationName;
+      uint32_t applicationVersion;
+      const char* pEngineName;
+      uint32_t engineVersion;
+      uint32_t apiVersion;
+    };
+    static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ApplicationInfo : public layout::ApplicationInfo
   {
     ApplicationInfo( const char* pApplicationName_ = nullptr,
                      uint32_t applicationVersion_ = 0,
                      const char* pEngineName_ = nullptr,
                      uint32_t engineVersion_ = 0,
                      uint32_t apiVersion_ = 0 )
-      : pApplicationName( pApplicationName_ )
-      , applicationVersion( applicationVersion_ )
-      , pEngineName( pEngineName_ )
-      , engineVersion( engineVersion_ )
-      , apiVersion( apiVersion_ )
+      : layout::ApplicationInfo( pApplicationName_, applicationVersion_, pEngineName_, engineVersion_, apiVersion_ )
     {}
 
     ApplicationInfo( VkApplicationInfo const & rhs )
-    {
-      *reinterpret_cast<VkApplicationInfo*>(this) = rhs;
-    }
+      : layout::ApplicationInfo( rhs )
+    {}
 
     ApplicationInfo& operator=( VkApplicationInfo const & rhs )
     {
@@ -18321,38 +19256,31 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eApplicationInfo;
-
-  public:
-    const void* pNext = nullptr;
-    const char* pApplicationName;
-    uint32_t applicationVersion;
-    const char* pEngineName;
-    uint32_t engineVersion;
-    uint32_t apiVersion;
+    using layout::ApplicationInfo::sType;
   };
   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!" );
 
   struct AttachmentDescription
   {
-    AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
-                           Format format_ = Format::eUndefined,
-                           SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
-                           AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
-                           AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
-                           AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
-                           AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
-                           ImageLayout initialLayout_ = ImageLayout::eUndefined,
-                           ImageLayout finalLayout_ = ImageLayout::eUndefined )
-      : flags( flags_ )
-      , format( format_ )
-      , samples( samples_ )
-      , loadOp( loadOp_ )
-      , storeOp( storeOp_ )
-      , stencilLoadOp( stencilLoadOp_ )
-      , stencilStoreOp( stencilStoreOp_ )
-      , initialLayout( initialLayout_ )
-      , finalLayout( finalLayout_ )
+    AttachmentDescription( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(),
+                           vk::Format format_ = vk::Format::eUndefined,
+                           vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+                           vk::AttachmentLoadOp loadOp_ = vk::AttachmentLoadOp::eLoad,
+                           vk::AttachmentStoreOp storeOp_ = vk::AttachmentStoreOp::eStore,
+                           vk::AttachmentLoadOp stencilLoadOp_ = vk::AttachmentLoadOp::eLoad,
+                           vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore,
+                           vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined,
+                           vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined )
+        : flags( flags_ )
+        , format( format_ )
+        , samples( samples_ )
+        , loadOp( loadOp_ )
+        , storeOp( storeOp_ )
+        , stencilLoadOp( stencilLoadOp_ )
+        , stencilStoreOp( stencilStoreOp_ )
+        , initialLayout( initialLayout_ )
+        , finalLayout( finalLayout_ )
     {}
 
     AttachmentDescription( VkAttachmentDescription const & rhs )
@@ -18366,55 +19294,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AttachmentDescription & setFlags( AttachmentDescriptionFlags flags_ )
+    AttachmentDescription & setFlags( vk::AttachmentDescriptionFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    AttachmentDescription & setFormat( Format format_ )
+    AttachmentDescription & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    AttachmentDescription & setSamples( SampleCountFlagBits samples_ )
+    AttachmentDescription & setSamples( vk::SampleCountFlagBits samples_ )
     {
       samples = samples_;
       return *this;
     }
 
-    AttachmentDescription & setLoadOp( AttachmentLoadOp loadOp_ )
+    AttachmentDescription & setLoadOp( vk::AttachmentLoadOp loadOp_ )
     {
       loadOp = loadOp_;
       return *this;
     }
 
-    AttachmentDescription & setStoreOp( AttachmentStoreOp storeOp_ )
+    AttachmentDescription & setStoreOp( vk::AttachmentStoreOp storeOp_ )
     {
       storeOp = storeOp_;
       return *this;
     }
 
-    AttachmentDescription & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+    AttachmentDescription & setStencilLoadOp( vk::AttachmentLoadOp stencilLoadOp_ )
     {
       stencilLoadOp = stencilLoadOp_;
       return *this;
     }
 
-    AttachmentDescription & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+    AttachmentDescription & setStencilStoreOp( vk::AttachmentStoreOp stencilStoreOp_ )
     {
       stencilStoreOp = stencilStoreOp_;
       return *this;
     }
 
-    AttachmentDescription & setInitialLayout( ImageLayout initialLayout_ )
+    AttachmentDescription & setInitialLayout( vk::ImageLayout initialLayout_ )
     {
       initialLayout = initialLayout_;
       return *this;
     }
 
-    AttachmentDescription & setFinalLayout( ImageLayout finalLayout_ )
+    AttachmentDescription & setFinalLayout( vk::ImageLayout finalLayout_ )
     {
       finalLayout = finalLayout_;
       return *this;
@@ -18448,44 +19376,89 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    AttachmentDescriptionFlags flags;
-    Format format;
-    SampleCountFlagBits samples;
-    AttachmentLoadOp loadOp;
-    AttachmentStoreOp storeOp;
-    AttachmentLoadOp stencilLoadOp;
-    AttachmentStoreOp stencilStoreOp;
-    ImageLayout initialLayout;
-    ImageLayout finalLayout;
+  public:
+    vk::AttachmentDescriptionFlags flags;
+    vk::Format format;
+    vk::SampleCountFlagBits samples;
+    vk::AttachmentLoadOp loadOp;
+    vk::AttachmentStoreOp storeOp;
+    vk::AttachmentLoadOp stencilLoadOp;
+    vk::AttachmentStoreOp stencilStoreOp;
+    vk::ImageLayout initialLayout;
+    vk::ImageLayout finalLayout;
   };
   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 AttachmentDescription2KHR
-  {
-    AttachmentDescription2KHR( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
-                               Format format_ = Format::eUndefined,
-                               SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
-                               AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
-                               AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
-                               AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
-                               AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
-                               ImageLayout initialLayout_ = ImageLayout::eUndefined,
-                               ImageLayout finalLayout_ = ImageLayout::eUndefined )
-      : flags( flags_ )
-      , format( format_ )
-      , samples( samples_ )
-      , loadOp( loadOp_ )
-      , storeOp( storeOp_ )
-      , stencilLoadOp( stencilLoadOp_ )
-      , stencilStoreOp( stencilStoreOp_ )
-      , initialLayout( initialLayout_ )
-      , finalLayout( finalLayout_ )
+  namespace layout
+  {
+    struct AttachmentDescription2KHR
+    {
+    protected:
+      AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(),
+                                 vk::Format format_ = vk::Format::eUndefined,
+                                 vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+                                 vk::AttachmentLoadOp loadOp_ = vk::AttachmentLoadOp::eLoad,
+                                 vk::AttachmentStoreOp storeOp_ = vk::AttachmentStoreOp::eStore,
+                                 vk::AttachmentLoadOp stencilLoadOp_ = vk::AttachmentLoadOp::eLoad,
+                                 vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore,
+                                 vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined,
+                                 vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined )
+        : flags( flags_ )
+        , format( format_ )
+        , samples( samples_ )
+        , loadOp( loadOp_ )
+        , storeOp( storeOp_ )
+        , stencilLoadOp( stencilLoadOp_ )
+        , stencilStoreOp( stencilStoreOp_ )
+        , initialLayout( initialLayout_ )
+        , finalLayout( finalLayout_ )
+      {}
+
+      AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs )
+      {
+        *reinterpret_cast<VkAttachmentDescription2KHR*>(this) = rhs;
+      }
+
+      AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs )
+      {
+        *reinterpret_cast<VkAttachmentDescription2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eAttachmentDescription2KHR;
+      const void* pNext = nullptr;
+      vk::AttachmentDescriptionFlags flags;
+      vk::Format format;
+      vk::SampleCountFlagBits samples;
+      vk::AttachmentLoadOp loadOp;
+      vk::AttachmentStoreOp storeOp;
+      vk::AttachmentLoadOp stencilLoadOp;
+      vk::AttachmentStoreOp stencilStoreOp;
+      vk::ImageLayout initialLayout;
+      vk::ImageLayout finalLayout;
+    };
+    static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AttachmentDescription2KHR : public layout::AttachmentDescription2KHR
+  {
+    AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(),
+                               vk::Format format_ = vk::Format::eUndefined,
+                               vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+                               vk::AttachmentLoadOp loadOp_ = vk::AttachmentLoadOp::eLoad,
+                               vk::AttachmentStoreOp storeOp_ = vk::AttachmentStoreOp::eStore,
+                               vk::AttachmentLoadOp stencilLoadOp_ = vk::AttachmentLoadOp::eLoad,
+                               vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore,
+                               vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined,
+                               vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined )
+      : layout::AttachmentDescription2KHR( flags_, format_, samples_, loadOp_, storeOp_, stencilLoadOp_, stencilStoreOp_, initialLayout_, finalLayout_ )
     {}
 
     AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs )
-    {
-      *reinterpret_cast<VkAttachmentDescription2KHR*>(this) = rhs;
-    }
+      : layout::AttachmentDescription2KHR( rhs )
+    {}
 
     AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs )
     {
@@ -18499,55 +19472,55 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AttachmentDescription2KHR & setFlags( AttachmentDescriptionFlags flags_ )
+    AttachmentDescription2KHR & setFlags( vk::AttachmentDescriptionFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    AttachmentDescription2KHR & setFormat( Format format_ )
+    AttachmentDescription2KHR & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    AttachmentDescription2KHR & setSamples( SampleCountFlagBits samples_ )
+    AttachmentDescription2KHR & setSamples( vk::SampleCountFlagBits samples_ )
     {
       samples = samples_;
       return *this;
     }
 
-    AttachmentDescription2KHR & setLoadOp( AttachmentLoadOp loadOp_ )
+    AttachmentDescription2KHR & setLoadOp( vk::AttachmentLoadOp loadOp_ )
     {
       loadOp = loadOp_;
       return *this;
     }
 
-    AttachmentDescription2KHR & setStoreOp( AttachmentStoreOp storeOp_ )
+    AttachmentDescription2KHR & setStoreOp( vk::AttachmentStoreOp storeOp_ )
     {
       storeOp = storeOp_;
       return *this;
     }
 
-    AttachmentDescription2KHR & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+    AttachmentDescription2KHR & setStencilLoadOp( vk::AttachmentLoadOp stencilLoadOp_ )
     {
       stencilLoadOp = stencilLoadOp_;
       return *this;
     }
 
-    AttachmentDescription2KHR & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+    AttachmentDescription2KHR & setStencilStoreOp( vk::AttachmentStoreOp stencilStoreOp_ )
     {
       stencilStoreOp = stencilStoreOp_;
       return *this;
     }
 
-    AttachmentDescription2KHR & setInitialLayout( ImageLayout initialLayout_ )
+    AttachmentDescription2KHR & setInitialLayout( vk::ImageLayout initialLayout_ )
     {
       initialLayout = initialLayout_;
       return *this;
     }
 
-    AttachmentDescription2KHR & setFinalLayout( ImageLayout finalLayout_ )
+    AttachmentDescription2KHR & setFinalLayout( vk::ImageLayout finalLayout_ )
     {
       finalLayout = finalLayout_;
       return *this;
@@ -18584,28 +19557,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAttachmentDescription2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    AttachmentDescriptionFlags flags;
-    Format format;
-    SampleCountFlagBits samples;
-    AttachmentLoadOp loadOp;
-    AttachmentStoreOp storeOp;
-    AttachmentLoadOp stencilLoadOp;
-    AttachmentStoreOp stencilStoreOp;
-    ImageLayout initialLayout;
-    ImageLayout finalLayout;
+    using layout::AttachmentDescription2KHR::sType;
   };
   static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<AttachmentDescription2KHR>::value, "struct wrapper is not a standard layout!" );
 
   struct AttachmentReference
   {
     AttachmentReference( uint32_t attachment_ = 0,
-                         ImageLayout layout_ = ImageLayout::eUndefined )
-      : attachment( attachment_ )
-      , layout( layout_ )
+                         vk::ImageLayout layout_ = vk::ImageLayout::eUndefined )
+        : attachment( attachment_ )
+        , layout( layout_ )
     {}
 
     AttachmentReference( VkAttachmentReference const & rhs )
@@ -18625,7 +19587,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AttachmentReference & setLayout( ImageLayout layout_ )
+    AttachmentReference & setLayout( vk::ImageLayout layout_ )
     {
       layout = layout_;
       return *this;
@@ -18652,25 +19614,58 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t attachment;
-    ImageLayout layout;
+    vk::ImageLayout layout;
   };
   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 AttachmentReference2KHR
+  namespace layout
+  {
+    struct AttachmentReference2KHR
+    {
+    protected:
+      AttachmentReference2KHR( uint32_t attachment_ = 0,
+                               vk::ImageLayout layout_ = vk::ImageLayout::eUndefined,
+                               vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() )
+        : attachment( attachment_ )
+        , layout( layout_ )
+        , aspectMask( aspectMask_ )
+      {}
+
+      AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs )
+      {
+        *reinterpret_cast<VkAttachmentReference2KHR*>(this) = rhs;
+      }
+
+      AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs )
+      {
+        *reinterpret_cast<VkAttachmentReference2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eAttachmentReference2KHR;
+      const void* pNext = nullptr;
+      uint32_t attachment;
+      vk::ImageLayout layout;
+      vk::ImageAspectFlags aspectMask;
+    };
+    static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct AttachmentReference2KHR : public layout::AttachmentReference2KHR
   {
     AttachmentReference2KHR( uint32_t attachment_ = 0,
-                             ImageLayout layout_ = ImageLayout::eUndefined,
-                             ImageAspectFlags aspectMask_ = ImageAspectFlags() )
-      : attachment( attachment_ )
-      , layout( layout_ )
-      , aspectMask( aspectMask_ )
+                             vk::ImageLayout layout_ = vk::ImageLayout::eUndefined,
+                             vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() )
+      : layout::AttachmentReference2KHR( attachment_, layout_, aspectMask_ )
     {}
 
     AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs )
-    {
-      *reinterpret_cast<VkAttachmentReference2KHR*>(this) = rhs;
-    }
+      : layout::AttachmentReference2KHR( rhs )
+    {}
 
     AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs )
     {
@@ -18690,13 +19685,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AttachmentReference2KHR & setLayout( ImageLayout layout_ )
+    AttachmentReference2KHR & setLayout( vk::ImageLayout layout_ )
     {
       layout = layout_;
       return *this;
     }
 
-    AttachmentReference2KHR & setAspectMask( ImageAspectFlags aspectMask_ )
+    AttachmentReference2KHR & setAspectMask( vk::ImageAspectFlags aspectMask_ )
     {
       aspectMask = aspectMask_;
       return *this;
@@ -18727,22 +19722,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eAttachmentReference2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t attachment;
-    ImageLayout layout;
-    ImageAspectFlags aspectMask;
+    using layout::AttachmentReference2KHR::sType;
   };
   static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<AttachmentReference2KHR>::value, "struct wrapper is not a standard layout!" );
 
   struct Extent2D
   {
     Extent2D( uint32_t width_ = 0,
               uint32_t height_ = 0 )
-      : width( width_ )
-      , height( height_ )
+        : width( width_ )
+        , height( height_ )
     {}
 
     Extent2D( VkExtent2D const & rhs )
@@ -18789,17 +19779,19 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
   {
     SampleLocationEXT( float x_ = 0,
                        float y_ = 0 )
-      : x( x_ )
-      , y( y_ )
+        : x( x_ )
+        , y( y_ )
     {}
 
     SampleLocationEXT( VkSampleLocationEXT const & rhs )
@@ -18846,27 +19838,62 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
+  namespace layout
   {
-    SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1,
-                            Extent2D sampleLocationGridSize_ = Extent2D(),
+    struct SampleLocationsInfoEXT
+    {
+    protected:
+      SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1,
+                              vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(),
+                              uint32_t sampleLocationsCount_ = 0,
+                              const vk::SampleLocationEXT* pSampleLocations_ = nullptr )
+        : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
+        , sampleLocationGridSize( sampleLocationGridSize_ )
+        , sampleLocationsCount( sampleLocationsCount_ )
+        , pSampleLocations( pSampleLocations_ )
+      {}
+
+      SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSampleLocationsInfoEXT*>(this) = rhs;
+      }
+
+      SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSampleLocationsInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSampleLocationsInfoEXT;
+      const void* pNext = nullptr;
+      vk::SampleCountFlagBits sampleLocationsPerPixel;
+      vk::Extent2D sampleLocationGridSize;
+      uint32_t sampleLocationsCount;
+      const vk::SampleLocationEXT* pSampleLocations;
+    };
+    static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SampleLocationsInfoEXT : public layout::SampleLocationsInfoEXT
+  {
+    SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1,
+                            vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(),
                             uint32_t sampleLocationsCount_ = 0,
-                            const SampleLocationEXT* pSampleLocations_ = nullptr )
-      : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
-      , sampleLocationGridSize( sampleLocationGridSize_ )
-      , sampleLocationsCount( sampleLocationsCount_ )
-      , pSampleLocations( pSampleLocations_ )
+                            const vk::SampleLocationEXT* pSampleLocations_ = nullptr )
+      : layout::SampleLocationsInfoEXT( sampleLocationsPerPixel_, sampleLocationGridSize_, sampleLocationsCount_, pSampleLocations_ )
     {}
 
     SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkSampleLocationsInfoEXT*>(this) = rhs;
-    }
+      : layout::SampleLocationsInfoEXT( rhs )
+    {}
 
     SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
     {
@@ -18880,13 +19907,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SampleLocationsInfoEXT & setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ )
+    SampleLocationsInfoEXT & setSampleLocationsPerPixel( vk::SampleCountFlagBits sampleLocationsPerPixel_ )
     {
       sampleLocationsPerPixel = sampleLocationsPerPixel_;
       return *this;
     }
 
-    SampleLocationsInfoEXT & setSampleLocationGridSize( Extent2D sampleLocationGridSize_ )
+    SampleLocationsInfoEXT & setSampleLocationGridSize( vk::Extent2D sampleLocationGridSize_ )
     {
       sampleLocationGridSize = sampleLocationGridSize_;
       return *this;
@@ -18898,7 +19925,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SampleLocationsInfoEXT & setPSampleLocations( const SampleLocationEXT* pSampleLocations_ )
+    SampleLocationsInfoEXT & setPSampleLocations( const vk::SampleLocationEXT* pSampleLocations_ )
     {
       pSampleLocations = pSampleLocations_;
       return *this;
@@ -18930,23 +19957,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSampleLocationsInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    SampleCountFlagBits sampleLocationsPerPixel;
-    Extent2D sampleLocationGridSize;
-    uint32_t sampleLocationsCount;
-    const SampleLocationEXT* pSampleLocations;
+    using layout::SampleLocationsInfoEXT::sType;
   };
   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!" );
 
   struct AttachmentSampleLocationsEXT
   {
     AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0,
-                                  SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : attachmentIndex( attachmentIndex_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
+                                  vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() )
+        : attachmentIndex( attachmentIndex_ )
+        , sampleLocationsInfo( sampleLocationsInfo_ )
     {}
 
     AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs )
@@ -18966,7 +19987,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    AttachmentSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+    AttachmentSampleLocationsEXT & setSampleLocationsInfo( vk::SampleLocationsInfoEXT sampleLocationsInfo_ )
     {
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
@@ -18993,20 +20014,50 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t attachmentIndex;
-    SampleLocationsInfoEXT sampleLocationsInfo;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct BaseInStructure
+    {
+    protected:
+      BaseInStructure()
+
+      {}
 
-  struct BaseInStructure
+      BaseInStructure( VkBaseInStructure const & rhs )
+      {
+        *reinterpret_cast<VkBaseInStructure*>(this) = rhs;
+      }
+
+      BaseInStructure& operator=( VkBaseInStructure const & rhs )
+      {
+        *reinterpret_cast<VkBaseInStructure*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType;
+      const struct vk::BaseInStructure* pNext = nullptr;
+    };
+    static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BaseInStructure : public layout::BaseInStructure
   {
-    BaseInStructure(  )
+    BaseInStructure()
+
+      : layout::BaseInStructure(  )
     {}
 
     BaseInStructure( VkBaseInStructure const & rhs )
-    {
-      *reinterpret_cast<VkBaseInStructure*>(this) = rhs;
-    }
+      : layout::BaseInStructure( rhs )
+    {}
 
     BaseInStructure& operator=( VkBaseInStructure const & rhs )
     {
@@ -19014,7 +20065,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BaseInStructure & setPNext( const struct BaseInStructure* pNext_ )
+    BaseInStructure & setPNext( const struct vk::BaseInStructure* pNext_ )
     {
       pNext = pNext_;
       return *this;
@@ -19041,20 +20092,49 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    StructureType sType;
-    const struct BaseInStructure* pNext = nullptr;
+  private:
+    using layout::BaseInStructure::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct BaseOutStructure
+    {
+    protected:
+      BaseOutStructure()
+
+      {}
 
-  struct BaseOutStructure
+      BaseOutStructure( VkBaseOutStructure const & rhs )
+      {
+        *reinterpret_cast<VkBaseOutStructure*>(this) = rhs;
+      }
+
+      BaseOutStructure& operator=( VkBaseOutStructure const & rhs )
+      {
+        *reinterpret_cast<VkBaseOutStructure*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType;
+      struct vk::BaseOutStructure* pNext = nullptr;
+    };
+    static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BaseOutStructure : public layout::BaseOutStructure
   {
-    BaseOutStructure(  )
+    BaseOutStructure()
+
+      : layout::BaseOutStructure(  )
     {}
 
     BaseOutStructure( VkBaseOutStructure const & rhs )
-    {
-      *reinterpret_cast<VkBaseOutStructure*>(this) = rhs;
-    }
+      : layout::BaseOutStructure( rhs )
+    {}
 
     BaseOutStructure& operator=( VkBaseOutStructure const & rhs )
     {
@@ -19062,7 +20142,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BaseOutStructure & setPNext( struct BaseOutStructure* pNext_ )
+    BaseOutStructure & setPNext( struct vk::BaseOutStructure* pNext_ )
     {
       pNext = pNext_;
       return *this;
@@ -19089,29 +20169,65 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    StructureType sType;
-    struct BaseOutStructure* pNext = nullptr;
+  private:
+    using layout::BaseOutStructure::sType;
   };
   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 BindAccelerationStructureMemoryInfoNV
+  namespace layout
   {
-    BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV(),
-                                           DeviceMemory memory_ = DeviceMemory(),
-                                           DeviceSize memoryOffset_ = 0,
+    struct BindAccelerationStructureMemoryInfoNV
+    {
+    protected:
+      BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(),
+                                             vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                                             vk::DeviceSize memoryOffset_ = 0,
+                                             uint32_t deviceIndexCount_ = 0,
+                                             const uint32_t* pDeviceIndices_ = nullptr )
+        : accelerationStructure( accelerationStructure_ )
+        , memory( memory_ )
+        , memoryOffset( memoryOffset_ )
+        , deviceIndexCount( deviceIndexCount_ )
+        , pDeviceIndices( pDeviceIndices_ )
+      {}
+
+      BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this) = rhs;
+      }
+
+      BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV;
+      const void* pNext = nullptr;
+      vk::AccelerationStructureNV accelerationStructure;
+      vk::DeviceMemory memory;
+      vk::DeviceSize memoryOffset;
+      uint32_t deviceIndexCount;
+      const uint32_t* pDeviceIndices;
+    };
+    static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BindAccelerationStructureMemoryInfoNV : public layout::BindAccelerationStructureMemoryInfoNV
+  {
+    BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(),
+                                           vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                                           vk::DeviceSize memoryOffset_ = 0,
                                            uint32_t deviceIndexCount_ = 0,
                                            const uint32_t* pDeviceIndices_ = nullptr )
-      : accelerationStructure( accelerationStructure_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-      , deviceIndexCount( deviceIndexCount_ )
-      , pDeviceIndices( pDeviceIndices_ )
+      : layout::BindAccelerationStructureMemoryInfoNV( accelerationStructure_, memory_, memoryOffset_, deviceIndexCount_, pDeviceIndices_ )
     {}
 
     BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this) = rhs;
-    }
+      : layout::BindAccelerationStructureMemoryInfoNV( rhs )
+    {}
 
     BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs )
     {
@@ -19125,19 +20241,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
+    BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( vk::AccelerationStructureNV accelerationStructure_ )
     {
       accelerationStructure = accelerationStructure_;
       return *this;
     }
 
-    BindAccelerationStructureMemoryInfoNV & setMemory( DeviceMemory memory_ )
+    BindAccelerationStructureMemoryInfoNV & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    BindAccelerationStructureMemoryInfoNV & setMemoryOffset( DeviceSize memoryOffset_ )
+    BindAccelerationStructureMemoryInfoNV & setMemoryOffset( vk::DeviceSize memoryOffset_ )
     {
       memoryOffset = memoryOffset_;
       return *this;
@@ -19182,30 +20298,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    AccelerationStructureNV accelerationStructure;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-    uint32_t deviceIndexCount;
-    const uint32_t* pDeviceIndices;
+    using layout::BindAccelerationStructureMemoryInfoNV::sType;
   };
   static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<BindAccelerationStructureMemoryInfoNV>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct BindBufferMemoryDeviceGroupInfo
+    {
+    protected:
+      BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
+                                       const uint32_t* pDeviceIndices_ = nullptr )
+        : deviceIndexCount( deviceIndexCount_ )
+        , pDeviceIndices( pDeviceIndices_ )
+      {}
+
+      BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this) = rhs;
+      }
+
+      BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this) = rhs;
+        return *this;
+      }
 
-  struct BindBufferMemoryDeviceGroupInfo
+    public:
+      vk::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo;
+      const void* pNext = nullptr;
+      uint32_t deviceIndexCount;
+      const uint32_t* pDeviceIndices;
+    };
+    static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BindBufferMemoryDeviceGroupInfo : public layout::BindBufferMemoryDeviceGroupInfo
   {
     BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
                                      const uint32_t* pDeviceIndices_ = nullptr )
-      : deviceIndexCount( deviceIndexCount_ )
-      , pDeviceIndices( pDeviceIndices_ )
+      : layout::BindBufferMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_ )
     {}
 
     BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs )
-    {
-      *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this) = rhs;
-    }
+      : layout::BindBufferMemoryDeviceGroupInfo( rhs )
+    {}
 
     BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs )
     {
@@ -19255,29 +20393,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceIndexCount;
-    const uint32_t* pDeviceIndices;
+    using layout::BindBufferMemoryDeviceGroupInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct BindBufferMemoryInfo
+    {
+    protected:
+      BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(),
+                            vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                            vk::DeviceSize memoryOffset_ = 0 )
+        : buffer( buffer_ )
+        , memory( memory_ )
+        , memoryOffset( memoryOffset_ )
+      {}
 
-  struct BindBufferMemoryInfo
+      BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindBufferMemoryInfo*>(this) = rhs;
+      }
+
+      BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindBufferMemoryInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBindBufferMemoryInfo;
+      const void* pNext = nullptr;
+      vk::Buffer buffer;
+      vk::DeviceMemory memory;
+      vk::DeviceSize memoryOffset;
+    };
+    static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BindBufferMemoryInfo : public layout::BindBufferMemoryInfo
   {
-    BindBufferMemoryInfo( Buffer buffer_ = Buffer(),
-                          DeviceMemory memory_ = DeviceMemory(),
-                          DeviceSize memoryOffset_ = 0 )
-      : buffer( buffer_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
+    BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(),
+                          vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                          vk::DeviceSize memoryOffset_ = 0 )
+      : layout::BindBufferMemoryInfo( buffer_, memory_, memoryOffset_ )
     {}
 
     BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs )
-    {
-      *reinterpret_cast<VkBindBufferMemoryInfo*>(this) = rhs;
-    }
+      : layout::BindBufferMemoryInfo( rhs )
+    {}
 
     BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs )
     {
@@ -19291,19 +20456,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindBufferMemoryInfo & setBuffer( Buffer buffer_ )
+    BindBufferMemoryInfo & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
     }
 
-    BindBufferMemoryInfo & setMemory( DeviceMemory memory_ )
+    BindBufferMemoryInfo & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    BindBufferMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ )
+    BindBufferMemoryInfo & setMemoryOffset( vk::DeviceSize memoryOffset_ )
     {
       memoryOffset = memoryOffset_;
       return *this;
@@ -19334,22 +20499,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBindBufferMemoryInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer buffer;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
+    using layout::BindBufferMemoryInfo::sType;
   };
   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!" );
 
   struct Offset2D
   {
     Offset2D( int32_t x_ = 0,
               int32_t y_ = 0 )
-      : x( x_ )
-      , y( y_ )
+        : x( x_ )
+        , y( y_ )
     {}
 
     Offset2D( VkOffset2D const & rhs )
@@ -19396,17 +20556,19 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
   {
-    Rect2D( Offset2D offset_ = Offset2D(),
-            Extent2D extent_ = Extent2D() )
-      : offset( offset_ )
-      , extent( extent_ )
+    Rect2D( vk::Offset2D offset_ = vk::Offset2D(),
+            vk::Extent2D extent_ = vk::Extent2D() )
+        : offset( offset_ )
+        , extent( extent_ )
     {}
 
     Rect2D( VkRect2D const & rhs )
@@ -19420,13 +20582,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    Rect2D & setOffset( Offset2D offset_ )
+    Rect2D & setOffset( vk::Offset2D offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    Rect2D & setExtent( Extent2D extent_ )
+    Rect2D & setExtent( vk::Extent2D extent_ )
     {
       extent = extent_;
       return *this;
@@ -19453,27 +20615,62 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Offset2D offset;
-    Extent2D extent;
+  public:
+    vk::Offset2D offset;
+    vk::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
+  namespace layout
+  {
+    struct BindImageMemoryDeviceGroupInfo
+    {
+    protected:
+      BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
+                                      const uint32_t* pDeviceIndices_ = nullptr,
+                                      uint32_t splitInstanceBindRegionCount_ = 0,
+                                      const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr )
+        : deviceIndexCount( deviceIndexCount_ )
+        , pDeviceIndices( pDeviceIndices_ )
+        , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
+        , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
+      {}
+
+      BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this) = rhs;
+      }
+
+      BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo;
+      const void* pNext = nullptr;
+      uint32_t deviceIndexCount;
+      const uint32_t* pDeviceIndices;
+      uint32_t splitInstanceBindRegionCount;
+      const vk::Rect2D* pSplitInstanceBindRegions;
+    };
+    static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BindImageMemoryDeviceGroupInfo : public layout::BindImageMemoryDeviceGroupInfo
   {
     BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
                                     const uint32_t* pDeviceIndices_ = nullptr,
                                     uint32_t splitInstanceBindRegionCount_ = 0,
-                                    const Rect2D* pSplitInstanceBindRegions_ = nullptr )
-      : deviceIndexCount( deviceIndexCount_ )
-      , pDeviceIndices( pDeviceIndices_ )
-      , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
-      , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
+                                    const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr )
+      : layout::BindImageMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_, splitInstanceBindRegionCount_, pSplitInstanceBindRegions_ )
     {}
 
     BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs )
-    {
-      *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this) = rhs;
-    }
+      : layout::BindImageMemoryDeviceGroupInfo( rhs )
+    {}
 
     BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs )
     {
@@ -19505,7 +20702,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions( const Rect2D* pSplitInstanceBindRegions_ )
+    BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions( const vk::Rect2D* pSplitInstanceBindRegions_ )
     {
       pSplitInstanceBindRegions = pSplitInstanceBindRegions_;
       return *this;
@@ -19537,31 +20734,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceIndexCount;
-    const uint32_t* pDeviceIndices;
-    uint32_t splitInstanceBindRegionCount;
-    const Rect2D* pSplitInstanceBindRegions;
+    using layout::BindImageMemoryDeviceGroupInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct BindImageMemoryInfo
+    {
+    protected:
+      BindImageMemoryInfo( vk::Image image_ = vk::Image(),
+                           vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                           vk::DeviceSize memoryOffset_ = 0 )
+        : image( image_ )
+        , memory( memory_ )
+        , memoryOffset( memoryOffset_ )
+      {}
+
+      BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindImageMemoryInfo*>(this) = rhs;
+      }
+
+      BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindImageMemoryInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBindImageMemoryInfo;
+      const void* pNext = nullptr;
+      vk::Image image;
+      vk::DeviceMemory memory;
+      vk::DeviceSize memoryOffset;
+    };
+    static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct BindImageMemoryInfo
+  struct BindImageMemoryInfo : public layout::BindImageMemoryInfo
   {
-    BindImageMemoryInfo( Image image_ = Image(),
-                         DeviceMemory memory_ = DeviceMemory(),
-                         DeviceSize memoryOffset_ = 0 )
-      : image( image_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
+    BindImageMemoryInfo( vk::Image image_ = vk::Image(),
+                         vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                         vk::DeviceSize memoryOffset_ = 0 )
+      : layout::BindImageMemoryInfo( image_, memory_, memoryOffset_ )
     {}
 
     BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs )
-    {
-      *reinterpret_cast<VkBindImageMemoryInfo*>(this) = rhs;
-    }
+      : layout::BindImageMemoryInfo( rhs )
+    {}
 
     BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs )
     {
@@ -19575,19 +20797,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindImageMemoryInfo & setImage( Image image_ )
+    BindImageMemoryInfo & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
     }
 
-    BindImageMemoryInfo & setMemory( DeviceMemory memory_ )
+    BindImageMemoryInfo & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    BindImageMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ )
+    BindImageMemoryInfo & setMemoryOffset( vk::DeviceSize memoryOffset_ )
     {
       memoryOffset = memoryOffset_;
       return *this;
@@ -19618,28 +20840,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBindImageMemoryInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
+    using layout::BindImageMemoryInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct BindImageMemorySwapchainInfoKHR
+    {
+    protected:
+      BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
+                                       uint32_t imageIndex_ = 0 )
+        : swapchain( swapchain_ )
+        , imageIndex( imageIndex_ )
+      {}
+
+      BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this) = rhs;
+      }
 
-  struct BindImageMemorySwapchainInfoKHR
+      BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR;
+      const void* pNext = nullptr;
+      vk::SwapchainKHR swapchain;
+      uint32_t imageIndex;
+    };
+    static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BindImageMemorySwapchainInfoKHR : public layout::BindImageMemorySwapchainInfoKHR
   {
-    BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(),
+    BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
                                      uint32_t imageIndex_ = 0 )
-      : swapchain( swapchain_ )
-      , imageIndex( imageIndex_ )
+      : layout::BindImageMemorySwapchainInfoKHR( swapchain_, imageIndex_ )
     {}
 
     BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this) = rhs;
-    }
+      : layout::BindImageMemorySwapchainInfoKHR( rhs )
+    {}
 
     BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs )
     {
@@ -19653,7 +20899,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindImageMemorySwapchainInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+    BindImageMemorySwapchainInfoKHR & setSwapchain( vk::SwapchainKHR swapchain_ )
     {
       swapchain = swapchain_;
       return *this;
@@ -19689,25 +20935,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
-    uint32_t imageIndex;
+    using layout::BindImageMemorySwapchainInfoKHR::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct BindImagePlaneMemoryInfo
+    {
+    protected:
+      BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor )
+        : planeAspect( planeAspect_ )
+      {}
+
+      BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this) = rhs;
+      }
+
+      BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this) = rhs;
+        return *this;
+      }
 
-  struct BindImagePlaneMemoryInfo
+    public:
+      vk::StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
+      const void* pNext = nullptr;
+      vk::ImageAspectFlagBits planeAspect;
+    };
+    static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BindImagePlaneMemoryInfo : public layout::BindImagePlaneMemoryInfo
   {
-    BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
-      : planeAspect( planeAspect_ )
+    BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor )
+      : layout::BindImagePlaneMemoryInfo( planeAspect_ )
     {}
 
     BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs )
-    {
-      *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this) = rhs;
-    }
+      : layout::BindImagePlaneMemoryInfo( rhs )
+    {}
 
     BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs )
     {
@@ -19721,7 +20990,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindImagePlaneMemoryInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+    BindImagePlaneMemoryInfo & setPlaneAspect( vk::ImageAspectFlagBits planeAspect_ )
     {
       planeAspect = planeAspect_;
       return *this;
@@ -19750,26 +21019,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageAspectFlagBits planeAspect;
+    using layout::BindImagePlaneMemoryInfo::sType;
   };
   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!" );
 
   struct SparseMemoryBind
   {
-    SparseMemoryBind( DeviceSize resourceOffset_ = 0,
-                      DeviceSize size_ = 0,
-                      DeviceMemory memory_ = DeviceMemory(),
-                      DeviceSize memoryOffset_ = 0,
-                      SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
-      : resourceOffset( resourceOffset_ )
-      , size( size_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-      , flags( flags_ )
+    SparseMemoryBind( vk::DeviceSize resourceOffset_ = 0,
+                      vk::DeviceSize size_ = 0,
+                      vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                      vk::DeviceSize memoryOffset_ = 0,
+                      vk::SparseMemoryBindFlags flags_ = vk::SparseMemoryBindFlags() )
+        : resourceOffset( resourceOffset_ )
+        , size( size_ )
+        , memory( memory_ )
+        , memoryOffset( memoryOffset_ )
+        , flags( flags_ )
     {}
 
     SparseMemoryBind( VkSparseMemoryBind const & rhs )
@@ -19783,31 +21049,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseMemoryBind & setResourceOffset( DeviceSize resourceOffset_ )
+    SparseMemoryBind & setResourceOffset( vk::DeviceSize resourceOffset_ )
     {
       resourceOffset = resourceOffset_;
       return *this;
     }
 
-    SparseMemoryBind & setSize( DeviceSize size_ )
+    SparseMemoryBind & setSize( vk::DeviceSize size_ )
     {
       size = size_;
       return *this;
     }
 
-    SparseMemoryBind & setMemory( DeviceMemory memory_ )
+    SparseMemoryBind & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    SparseMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ )
+    SparseMemoryBind & setMemoryOffset( vk::DeviceSize memoryOffset_ )
     {
       memoryOffset = memoryOffset_;
       return *this;
     }
 
-    SparseMemoryBind & setFlags( SparseMemoryBindFlags flags_ )
+    SparseMemoryBind & setFlags( vk::SparseMemoryBindFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -19837,22 +21103,24 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DeviceSize resourceOffset;
-    DeviceSize size;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-    SparseMemoryBindFlags flags;
+  public:
+    vk::DeviceSize resourceOffset;
+    vk::DeviceSize size;
+    vk::DeviceMemory memory;
+    vk::DeviceSize memoryOffset;
+    vk::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
   {
-    SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(),
+    SparseBufferMemoryBindInfo( vk::Buffer buffer_ = vk::Buffer(),
                                 uint32_t bindCount_ = 0,
-                                const SparseMemoryBind* pBinds_ = nullptr )
-      : buffer( buffer_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
+                                const vk::SparseMemoryBind* pBinds_ = nullptr )
+        : buffer( buffer_ )
+        , bindCount( bindCount_ )
+        , pBinds( pBinds_ )
     {}
 
     SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
@@ -19866,7 +21134,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseBufferMemoryBindInfo & setBuffer( Buffer buffer_ )
+    SparseBufferMemoryBindInfo & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
@@ -19878,7 +21146,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseBufferMemoryBindInfo & setPBinds( const SparseMemoryBind* pBinds_ )
+    SparseBufferMemoryBindInfo & setPBinds( const vk::SparseMemoryBind* pBinds_ )
     {
       pBinds = pBinds_;
       return *this;
@@ -19906,20 +21174,22 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Buffer buffer;
+  public:
+    vk::Buffer buffer;
     uint32_t bindCount;
-    const SparseMemoryBind* pBinds;
+    const vk::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
   {
-    SparseImageOpaqueMemoryBindInfo( Image image_ = Image(),
+    SparseImageOpaqueMemoryBindInfo( vk::Image image_ = vk::Image(),
                                      uint32_t bindCount_ = 0,
-                                     const SparseMemoryBind* pBinds_ = nullptr )
-      : image( image_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
+                                     const vk::SparseMemoryBind* pBinds_ = nullptr )
+        : image( image_ )
+        , bindCount( bindCount_ )
+        , pBinds( pBinds_ )
     {}
 
     SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
@@ -19933,7 +21203,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseImageOpaqueMemoryBindInfo & setImage( Image image_ )
+    SparseImageOpaqueMemoryBindInfo & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
@@ -19945,7 +21215,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseImageOpaqueMemoryBindInfo & setPBinds( const SparseMemoryBind* pBinds_ )
+    SparseImageOpaqueMemoryBindInfo & setPBinds( const vk::SparseMemoryBind* pBinds_ )
     {
       pBinds = pBinds_;
       return *this;
@@ -19973,20 +21243,22 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Image image;
+  public:
+    vk::Image image;
     uint32_t bindCount;
-    const SparseMemoryBind* pBinds;
+    const vk::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
   {
-    ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+    ImageSubresource( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
                       uint32_t mipLevel_ = 0,
                       uint32_t arrayLayer_ = 0 )
-      : aspectMask( aspectMask_ )
-      , mipLevel( mipLevel_ )
-      , arrayLayer( arrayLayer_ )
+        : aspectMask( aspectMask_ )
+        , mipLevel( mipLevel_ )
+        , arrayLayer( arrayLayer_ )
     {}
 
     ImageSubresource( VkImageSubresource const & rhs )
@@ -20000,7 +21272,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageSubresource & setAspectMask( ImageAspectFlags aspectMask_ )
+    ImageSubresource & setAspectMask( vk::ImageAspectFlags aspectMask_ )
     {
       aspectMask = aspectMask_;
       return *this;
@@ -20040,20 +21312,22 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageAspectFlags aspectMask;
+  public:
+    vk::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
   {
     Offset3D( int32_t x_ = 0,
               int32_t y_ = 0,
               int32_t z_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
+        : x( x_ )
+        , y( y_ )
+        , z( z_ )
     {}
 
     explicit Offset3D( Offset2D const& offset2D,
@@ -20061,6 +21335,7 @@ namespace VULKAN_HPP_NAMESPACE
       : x( offset2D.x )
       , y( offset2D.y )
       , z( z_ )
+
     {}
 
     Offset3D( VkOffset3D const & rhs )
@@ -20114,20 +21389,22 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
   {
     Extent3D( uint32_t width_ = 0,
               uint32_t height_ = 0,
               uint32_t depth_ = 0 )
-      : width( width_ )
-      , height( height_ )
-      , depth( depth_ )
+        : width( width_ )
+        , height( height_ )
+        , depth( depth_ )
     {}
 
     explicit Extent3D( Extent2D const& extent2D,
@@ -20135,6 +21412,7 @@ namespace VULKAN_HPP_NAMESPACE
       : width( extent2D.width )
       , height( extent2D.height )
       , depth( depth_ )
+
     {}
 
     Extent3D( VkExtent3D const & rhs )
@@ -20188,26 +21466,28 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
   {
-    SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(),
-                           Offset3D offset_ = Offset3D(),
-                           Extent3D extent_ = Extent3D(),
-                           DeviceMemory memory_ = DeviceMemory(),
-                           DeviceSize memoryOffset_ = 0,
-                           SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
-      : subresource( subresource_ )
-      , offset( offset_ )
-      , extent( extent_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-      , flags( flags_ )
+    SparseImageMemoryBind( vk::ImageSubresource subresource_ = vk::ImageSubresource(),
+                           vk::Offset3D offset_ = vk::Offset3D(),
+                           vk::Extent3D extent_ = vk::Extent3D(),
+                           vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                           vk::DeviceSize memoryOffset_ = 0,
+                           vk::SparseMemoryBindFlags flags_ = vk::SparseMemoryBindFlags() )
+        : subresource( subresource_ )
+        , offset( offset_ )
+        , extent( extent_ )
+        , memory( memory_ )
+        , memoryOffset( memoryOffset_ )
+        , flags( flags_ )
     {}
 
     SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
@@ -20221,37 +21501,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseImageMemoryBind & setSubresource( ImageSubresource subresource_ )
+    SparseImageMemoryBind & setSubresource( vk::ImageSubresource subresource_ )
     {
       subresource = subresource_;
       return *this;
     }
 
-    SparseImageMemoryBind & setOffset( Offset3D offset_ )
+    SparseImageMemoryBind & setOffset( vk::Offset3D offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    SparseImageMemoryBind & setExtent( Extent3D extent_ )
+    SparseImageMemoryBind & setExtent( vk::Extent3D extent_ )
     {
       extent = extent_;
       return *this;
     }
 
-    SparseImageMemoryBind & setMemory( DeviceMemory memory_ )
+    SparseImageMemoryBind & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    SparseImageMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ )
+    SparseImageMemoryBind & setMemoryOffset( vk::DeviceSize memoryOffset_ )
     {
       memoryOffset = memoryOffset_;
       return *this;
     }
 
-    SparseImageMemoryBind & setFlags( SparseMemoryBindFlags flags_ )
+    SparseImageMemoryBind & setFlags( vk::SparseMemoryBindFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -20282,23 +21562,25 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageSubresource subresource;
-    Offset3D offset;
-    Extent3D extent;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-    SparseMemoryBindFlags flags;
+  public:
+    vk::ImageSubresource subresource;
+    vk::Offset3D offset;
+    vk::Extent3D extent;
+    vk::DeviceMemory memory;
+    vk::DeviceSize memoryOffset;
+    vk::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
   {
-    SparseImageMemoryBindInfo( Image image_ = Image(),
+    SparseImageMemoryBindInfo( vk::Image image_ = vk::Image(),
                                uint32_t bindCount_ = 0,
-                               const SparseImageMemoryBind* pBinds_ = nullptr )
-      : image( image_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
+                               const vk::SparseImageMemoryBind* pBinds_ = nullptr )
+        : image( image_ )
+        , bindCount( bindCount_ )
+        , pBinds( pBinds_ )
     {}
 
     SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
@@ -20312,7 +21594,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseImageMemoryBindInfo & setImage( Image image_ )
+    SparseImageMemoryBindInfo & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
@@ -20324,7 +21606,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SparseImageMemoryBindInfo & setPBinds( const SparseImageMemoryBind* pBinds_ )
+    SparseImageMemoryBindInfo & setPBinds( const vk::SparseImageMemoryBind* pBinds_ )
     {
       pBinds = pBinds_;
       return *this;
@@ -20352,40 +21634,87 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Image image;
+  public:
+    vk::Image image;
     uint32_t bindCount;
-    const SparseImageMemoryBind* pBinds;
+    const vk::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!" );
+
+  namespace layout
+  {
+    struct BindSparseInfo
+    {
+    protected:
+      BindSparseInfo( uint32_t waitSemaphoreCount_ = 0,
+                      const vk::Semaphore* pWaitSemaphores_ = nullptr,
+                      uint32_t bufferBindCount_ = 0,
+                      const vk::SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr,
+                      uint32_t imageOpaqueBindCount_ = 0,
+                      const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr,
+                      uint32_t imageBindCount_ = 0,
+                      const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
+                      uint32_t signalSemaphoreCount_ = 0,
+                      const vk::Semaphore* pSignalSemaphores_ = nullptr )
+        : waitSemaphoreCount( waitSemaphoreCount_ )
+        , pWaitSemaphores( pWaitSemaphores_ )
+        , bufferBindCount( bufferBindCount_ )
+        , pBufferBinds( pBufferBinds_ )
+        , imageOpaqueBindCount( imageOpaqueBindCount_ )
+        , pImageOpaqueBinds( pImageOpaqueBinds_ )
+        , imageBindCount( imageBindCount_ )
+        , pImageBinds( pImageBinds_ )
+        , signalSemaphoreCount( signalSemaphoreCount_ )
+        , pSignalSemaphores( pSignalSemaphores_ )
+      {}
+
+      BindSparseInfo( VkBindSparseInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindSparseInfo*>(this) = rhs;
+      }
 
-  struct BindSparseInfo
+      BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
+      {
+        *reinterpret_cast<VkBindSparseInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBindSparseInfo;
+      const void* pNext = nullptr;
+      uint32_t waitSemaphoreCount;
+      const vk::Semaphore* pWaitSemaphores;
+      uint32_t bufferBindCount;
+      const vk::SparseBufferMemoryBindInfo* pBufferBinds;
+      uint32_t imageOpaqueBindCount;
+      const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
+      uint32_t imageBindCount;
+      const vk::SparseImageMemoryBindInfo* pImageBinds;
+      uint32_t signalSemaphoreCount;
+      const vk::Semaphore* pSignalSemaphores;
+    };
+    static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BindSparseInfo : public layout::BindSparseInfo
   {
     BindSparseInfo( uint32_t waitSemaphoreCount_ = 0,
-                    const Semaphore* pWaitSemaphores_ = nullptr,
+                    const vk::Semaphore* pWaitSemaphores_ = nullptr,
                     uint32_t bufferBindCount_ = 0,
-                    const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr,
+                    const vk::SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr,
                     uint32_t imageOpaqueBindCount_ = 0,
-                    const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr,
+                    const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr,
                     uint32_t imageBindCount_ = 0,
-                    const SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
+                    const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
                     uint32_t signalSemaphoreCount_ = 0,
-                    const Semaphore* pSignalSemaphores_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , bufferBindCount( bufferBindCount_ )
-      , pBufferBinds( pBufferBinds_ )
-      , imageOpaqueBindCount( imageOpaqueBindCount_ )
-      , pImageOpaqueBinds( pImageOpaqueBinds_ )
-      , imageBindCount( imageBindCount_ )
-      , pImageBinds( pImageBinds_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphores( pSignalSemaphores_ )
+                    const vk::Semaphore* pSignalSemaphores_ = nullptr )
+      : layout::BindSparseInfo( waitSemaphoreCount_, pWaitSemaphores_, bufferBindCount_, pBufferBinds_, imageOpaqueBindCount_, pImageOpaqueBinds_, imageBindCount_, pImageBinds_, signalSemaphoreCount_, pSignalSemaphores_ )
     {}
 
     BindSparseInfo( VkBindSparseInfo const & rhs )
-    {
-      *reinterpret_cast<VkBindSparseInfo*>(this) = rhs;
-    }
+      : layout::BindSparseInfo( rhs )
+    {}
 
     BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
     {
@@ -20405,7 +21734,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindSparseInfo & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+    BindSparseInfo & setPWaitSemaphores( const vk::Semaphore* pWaitSemaphores_ )
     {
       pWaitSemaphores = pWaitSemaphores_;
       return *this;
@@ -20417,7 +21746,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindSparseInfo & setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
+    BindSparseInfo & setPBufferBinds( const vk::SparseBufferMemoryBindInfo* pBufferBinds_ )
     {
       pBufferBinds = pBufferBinds_;
       return *this;
@@ -20429,7 +21758,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindSparseInfo & setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
+    BindSparseInfo & setPImageOpaqueBinds( const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
     {
       pImageOpaqueBinds = pImageOpaqueBinds_;
       return *this;
@@ -20441,7 +21770,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindSparseInfo & setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
+    BindSparseInfo & setPImageBinds( const vk::SparseImageMemoryBindInfo* pImageBinds_ )
     {
       pImageBinds = pImageBinds_;
       return *this;
@@ -20453,7 +21782,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BindSparseInfo & setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+    BindSparseInfo & setPSignalSemaphores( const vk::Semaphore* pSignalSemaphores_ )
     {
       pSignalSemaphores = pSignalSemaphores_;
       return *this;
@@ -20491,31 +21820,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBindSparseInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    uint32_t bufferBindCount;
-    const SparseBufferMemoryBindInfo* pBufferBinds;
-    uint32_t imageOpaqueBindCount;
-    const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
-    uint32_t imageBindCount;
-    const SparseImageMemoryBindInfo* pImageBinds;
-    uint32_t signalSemaphoreCount;
-    const Semaphore* pSignalSemaphores;
+    using layout::BindSparseInfo::sType;
   };
   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!" );
 
   struct BufferCopy
   {
-    BufferCopy( DeviceSize srcOffset_ = 0,
-                DeviceSize dstOffset_ = 0,
-                DeviceSize size_ = 0 )
-      : srcOffset( srcOffset_ )
-      , dstOffset( dstOffset_ )
-      , size( size_ )
+    BufferCopy( vk::DeviceSize srcOffset_ = 0,
+                vk::DeviceSize dstOffset_ = 0,
+                vk::DeviceSize size_ = 0 )
+        : srcOffset( srcOffset_ )
+        , dstOffset( dstOffset_ )
+        , size( size_ )
     {}
 
     BufferCopy( VkBufferCopy const & rhs )
@@ -20529,19 +21846,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferCopy & setSrcOffset( DeviceSize srcOffset_ )
+    BufferCopy & setSrcOffset( vk::DeviceSize srcOffset_ )
     {
       srcOffset = srcOffset_;
       return *this;
     }
 
-    BufferCopy & setDstOffset( DeviceSize dstOffset_ )
+    BufferCopy & setDstOffset( vk::DeviceSize dstOffset_ )
     {
       dstOffset = dstOffset_;
       return *this;
     }
 
-    BufferCopy & setSize( DeviceSize size_ )
+    BufferCopy & setSize( vk::DeviceSize size_ )
     {
       size = size_;
       return *this;
@@ -20569,32 +21886,71 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DeviceSize srcOffset;
-    DeviceSize dstOffset;
-    DeviceSize size;
+  public:
+    vk::DeviceSize srcOffset;
+    vk::DeviceSize dstOffset;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct BufferCreateInfo
+    {
+    protected:
+      BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
+                        vk::DeviceSize size_ = 0,
+                        vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
+                        vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+                        uint32_t queueFamilyIndexCount_ = 0,
+                        const uint32_t* pQueueFamilyIndices_ = nullptr )
+        : flags( flags_ )
+        , size( size_ )
+        , usage( usage_ )
+        , sharingMode( sharingMode_ )
+        , queueFamilyIndexCount( queueFamilyIndexCount_ )
+        , pQueueFamilyIndices( pQueueFamilyIndices_ )
+      {}
+
+      BufferCreateInfo( VkBufferCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkBufferCreateInfo*>(this) = rhs;
+      }
+
+      BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkBufferCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBufferCreateInfo;
+      const void* pNext = nullptr;
+      vk::BufferCreateFlags flags;
+      vk::DeviceSize size;
+      vk::BufferUsageFlags usage;
+      vk::SharingMode sharingMode;
+      uint32_t queueFamilyIndexCount;
+      const uint32_t* pQueueFamilyIndices;
+    };
+    static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct BufferCreateInfo
+  struct BufferCreateInfo : public layout::BufferCreateInfo
   {
-    BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
-                      DeviceSize size_ = 0,
-                      BufferUsageFlags usage_ = BufferUsageFlags(),
-                      SharingMode sharingMode_ = SharingMode::eExclusive,
+    BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
+                      vk::DeviceSize size_ = 0,
+                      vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
+                      vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
                       uint32_t queueFamilyIndexCount_ = 0,
                       const uint32_t* pQueueFamilyIndices_ = nullptr )
-      : flags( flags_ )
-      , size( size_ )
-      , usage( usage_ )
-      , sharingMode( sharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
+      : layout::BufferCreateInfo( flags_, size_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ )
     {}
 
     BufferCreateInfo( VkBufferCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkBufferCreateInfo*>(this) = rhs;
-    }
+      : layout::BufferCreateInfo( rhs )
+    {}
 
     BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
     {
@@ -20608,25 +21964,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferCreateInfo & setFlags( BufferCreateFlags flags_ )
+    BufferCreateInfo & setFlags( vk::BufferCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    BufferCreateInfo & setSize( DeviceSize size_ )
+    BufferCreateInfo & setSize( vk::DeviceSize size_ )
     {
       size = size_;
       return *this;
     }
 
-    BufferCreateInfo & setUsage( BufferUsageFlags usage_ )
+    BufferCreateInfo & setUsage( vk::BufferUsageFlags usage_ )
     {
       usage = usage_;
       return *this;
     }
 
-    BufferCreateInfo & setSharingMode( SharingMode sharingMode_ )
+    BufferCreateInfo & setSharingMode( vk::SharingMode sharingMode_ )
     {
       sharingMode = sharingMode_;
       return *this;
@@ -20672,29 +22028,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBufferCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    BufferCreateFlags flags;
-    DeviceSize size;
-    BufferUsageFlags usage;
-    SharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
+    using layout::BufferCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct BufferDeviceAddressCreateInfoEXT
+    {
+    protected:
+      BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 )
+        : deviceAddress( deviceAddress_ )
+      {}
+
+      BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this) = rhs;
+      }
+
+      BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct BufferDeviceAddressCreateInfoEXT
+    public:
+      vk::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::DeviceAddress deviceAddress;
+    };
+    static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BufferDeviceAddressCreateInfoEXT : public layout::BufferDeviceAddressCreateInfoEXT
   {
-    BufferDeviceAddressCreateInfoEXT( DeviceAddress deviceAddress_ = 0 )
-      : deviceAddress( deviceAddress_ )
+    BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 )
+      : layout::BufferDeviceAddressCreateInfoEXT( deviceAddress_ )
     {}
 
     BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::BufferDeviceAddressCreateInfoEXT( rhs )
+    {}
 
     BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs )
     {
@@ -20708,7 +22083,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ )
+    BufferDeviceAddressCreateInfoEXT & setDeviceAddress( vk::DeviceAddress deviceAddress_ )
     {
       deviceAddress = deviceAddress_;
       return *this;
@@ -20737,24 +22112,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceAddress deviceAddress;
+    using layout::BufferDeviceAddressCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct BufferDeviceAddressInfoEXT
+    {
+    protected:
+      BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() )
+        : buffer( buffer_ )
+      {}
+
+      BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkBufferDeviceAddressInfoEXT*>(this) = rhs;
+      }
 
-  struct BufferDeviceAddressInfoEXT
+      BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkBufferDeviceAddressInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBufferDeviceAddressInfoEXT;
+      const void* pNext = nullptr;
+      vk::Buffer buffer;
+    };
+    static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BufferDeviceAddressInfoEXT : public layout::BufferDeviceAddressInfoEXT
   {
-    BufferDeviceAddressInfoEXT( Buffer buffer_ = Buffer() )
-      : buffer( buffer_ )
+    BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() )
+      : layout::BufferDeviceAddressInfoEXT( buffer_ )
     {}
 
     BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkBufferDeviceAddressInfoEXT*>(this) = rhs;
-    }
+      : layout::BufferDeviceAddressInfoEXT( rhs )
+    {}
 
     BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs )
     {
@@ -20768,7 +22167,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferDeviceAddressInfoEXT & setBuffer( Buffer buffer_ )
+    BufferDeviceAddressInfoEXT & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
@@ -20797,24 +22196,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBufferDeviceAddressInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer buffer;
+    using layout::BufferDeviceAddressInfoEXT::sType;
   };
   static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<BufferDeviceAddressInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct ImageSubresourceLayers
   {
-    ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+    ImageSubresourceLayers( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
                             uint32_t mipLevel_ = 0,
                             uint32_t baseArrayLayer_ = 0,
                             uint32_t layerCount_ = 0 )
-      : aspectMask( aspectMask_ )
-      , mipLevel( mipLevel_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
+        : aspectMask( aspectMask_ )
+        , mipLevel( mipLevel_ )
+        , baseArrayLayer( baseArrayLayer_ )
+        , layerCount( layerCount_ )
     {}
 
     ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
@@ -20828,7 +22224,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageSubresourceLayers & setAspectMask( ImageAspectFlags aspectMask_ )
+    ImageSubresourceLayers & setAspectMask( vk::ImageAspectFlags aspectMask_ )
     {
       aspectMask = aspectMask_;
       return *this;
@@ -20875,27 +22271,29 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageAspectFlags aspectMask;
+  public:
+    vk::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
   {
-    BufferImageCopy( DeviceSize bufferOffset_ = 0,
+    BufferImageCopy( vk::DeviceSize bufferOffset_ = 0,
                      uint32_t bufferRowLength_ = 0,
                      uint32_t bufferImageHeight_ = 0,
-                     ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(),
-                     Offset3D imageOffset_ = Offset3D(),
-                     Extent3D imageExtent_ = Extent3D() )
-      : bufferOffset( bufferOffset_ )
-      , bufferRowLength( bufferRowLength_ )
-      , bufferImageHeight( bufferImageHeight_ )
-      , imageSubresource( imageSubresource_ )
-      , imageOffset( imageOffset_ )
-      , imageExtent( imageExtent_ )
+                     vk::ImageSubresourceLayers imageSubresource_ = vk::ImageSubresourceLayers(),
+                     vk::Offset3D imageOffset_ = vk::Offset3D(),
+                     vk::Extent3D imageExtent_ = vk::Extent3D() )
+        : bufferOffset( bufferOffset_ )
+        , bufferRowLength( bufferRowLength_ )
+        , bufferImageHeight( bufferImageHeight_ )
+        , imageSubresource( imageSubresource_ )
+        , imageOffset( imageOffset_ )
+        , imageExtent( imageExtent_ )
     {}
 
     BufferImageCopy( VkBufferImageCopy const & rhs )
@@ -20909,7 +22307,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferImageCopy & setBufferOffset( DeviceSize bufferOffset_ )
+    BufferImageCopy & setBufferOffset( vk::DeviceSize bufferOffset_ )
     {
       bufferOffset = bufferOffset_;
       return *this;
@@ -20927,19 +22325,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferImageCopy & setImageSubresource( ImageSubresourceLayers imageSubresource_ )
+    BufferImageCopy & setImageSubresource( vk::ImageSubresourceLayers imageSubresource_ )
     {
       imageSubresource = imageSubresource_;
       return *this;
     }
 
-    BufferImageCopy & setImageOffset( Offset3D imageOffset_ )
+    BufferImageCopy & setImageOffset( vk::Offset3D imageOffset_ )
     {
       imageOffset = imageOffset_;
       return *this;
     }
 
-    BufferImageCopy & setImageExtent( Extent3D imageExtent_ )
+    BufferImageCopy & setImageExtent( vk::Extent3D imageExtent_ )
     {
       imageExtent = imageExtent_;
       return *this;
@@ -20970,37 +22368,78 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DeviceSize bufferOffset;
+  public:
+    vk::DeviceSize bufferOffset;
     uint32_t bufferRowLength;
     uint32_t bufferImageHeight;
-    ImageSubresourceLayers imageSubresource;
-    Offset3D imageOffset;
-    Extent3D imageExtent;
+    vk::ImageSubresourceLayers imageSubresource;
+    vk::Offset3D imageOffset;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct BufferMemoryBarrier
+    {
+    protected:
+      BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                           vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+                           uint32_t srcQueueFamilyIndex_ = 0,
+                           uint32_t dstQueueFamilyIndex_ = 0,
+                           vk::Buffer buffer_ = vk::Buffer(),
+                           vk::DeviceSize offset_ = 0,
+                           vk::DeviceSize size_ = 0 )
+        : srcAccessMask( srcAccessMask_ )
+        , dstAccessMask( dstAccessMask_ )
+        , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+        , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+        , buffer( buffer_ )
+        , offset( offset_ )
+        , size( size_ )
+      {}
 
-  struct BufferMemoryBarrier
+      BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
+      {
+        *reinterpret_cast<VkBufferMemoryBarrier*>(this) = rhs;
+      }
+
+      BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
+      {
+        *reinterpret_cast<VkBufferMemoryBarrier*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBufferMemoryBarrier;
+      const void* pNext = nullptr;
+      vk::AccessFlags srcAccessMask;
+      vk::AccessFlags dstAccessMask;
+      uint32_t srcQueueFamilyIndex;
+      uint32_t dstQueueFamilyIndex;
+      vk::Buffer buffer;
+      vk::DeviceSize offset;
+      vk::DeviceSize size;
+    };
+    static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BufferMemoryBarrier : public layout::BufferMemoryBarrier
   {
-    BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
-                         AccessFlags dstAccessMask_ = AccessFlags(),
+    BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                         vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
                          uint32_t srcQueueFamilyIndex_ = 0,
                          uint32_t dstQueueFamilyIndex_ = 0,
-                         Buffer buffer_ = Buffer(),
-                         DeviceSize offset_ = 0,
-                         DeviceSize size_ = 0 )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
-      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
-      , buffer( buffer_ )
-      , offset( offset_ )
-      , size( size_ )
+                         vk::Buffer buffer_ = vk::Buffer(),
+                         vk::DeviceSize offset_ = 0,
+                         vk::DeviceSize size_ = 0 )
+      : layout::BufferMemoryBarrier( srcAccessMask_, dstAccessMask_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, buffer_, offset_, size_ )
     {}
 
     BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
-    {
-      *reinterpret_cast<VkBufferMemoryBarrier*>(this) = rhs;
-    }
+      : layout::BufferMemoryBarrier( rhs )
+    {}
 
     BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
     {
@@ -21014,13 +22453,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    BufferMemoryBarrier & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
     {
       srcAccessMask = srcAccessMask_;
       return *this;
     }
 
-    BufferMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+    BufferMemoryBarrier & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
     {
       dstAccessMask = dstAccessMask_;
       return *this;
@@ -21038,19 +22477,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferMemoryBarrier & setBuffer( Buffer buffer_ )
+    BufferMemoryBarrier & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
     }
 
-    BufferMemoryBarrier & setOffset( DeviceSize offset_ )
+    BufferMemoryBarrier & setOffset( vk::DeviceSize offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    BufferMemoryBarrier & setSize( DeviceSize size_ )
+    BufferMemoryBarrier & setSize( vk::DeviceSize size_ )
     {
       size = size_;
       return *this;
@@ -21085,30 +22524,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBufferMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    Buffer buffer;
-    DeviceSize offset;
-    DeviceSize size;
+    using layout::BufferMemoryBarrier::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct BufferMemoryRequirementsInfo2
+    {
+    protected:
+      BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() )
+        : buffer( buffer_ )
+      {}
+
+      BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this) = rhs;
+      }
+
+      BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2;
+      const void* pNext = nullptr;
+      vk::Buffer buffer;
+    };
+    static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" );
+  }
 
-  struct BufferMemoryRequirementsInfo2
+  struct BufferMemoryRequirementsInfo2 : public layout::BufferMemoryRequirementsInfo2
   {
-    BufferMemoryRequirementsInfo2( Buffer buffer_ = Buffer() )
-      : buffer( buffer_ )
+    BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() )
+      : layout::BufferMemoryRequirementsInfo2( buffer_ )
     {}
 
     BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs )
-    {
-      *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this) = rhs;
-    }
+      : layout::BufferMemoryRequirementsInfo2( rhs )
+    {}
 
     BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs )
     {
@@ -21122,7 +22579,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferMemoryRequirementsInfo2 & setBuffer( Buffer buffer_ )
+    BufferMemoryRequirementsInfo2 & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
@@ -21151,32 +22608,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBufferMemoryRequirementsInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer buffer;
+    using layout::BufferMemoryRequirementsInfo2::sType;
   };
   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!" );
 
-  struct BufferViewCreateInfo
+  namespace layout
   {
-    BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(),
-                          Buffer buffer_ = Buffer(),
-                          Format format_ = Format::eUndefined,
-                          DeviceSize offset_ = 0,
-                          DeviceSize range_ = 0 )
-      : flags( flags_ )
-      , buffer( buffer_ )
-      , format( format_ )
-      , offset( offset_ )
-      , range( range_ )
+    struct BufferViewCreateInfo
+    {
+    protected:
+      BufferViewCreateInfo( vk::BufferViewCreateFlags flags_ = vk::BufferViewCreateFlags(),
+                            vk::Buffer buffer_ = vk::Buffer(),
+                            vk::Format format_ = vk::Format::eUndefined,
+                            vk::DeviceSize offset_ = 0,
+                            vk::DeviceSize range_ = 0 )
+        : flags( flags_ )
+        , buffer( buffer_ )
+        , format( format_ )
+        , offset( offset_ )
+        , range( range_ )
+      {}
+
+      BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkBufferViewCreateInfo*>(this) = rhs;
+      }
+
+      BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkBufferViewCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eBufferViewCreateInfo;
+      const void* pNext = nullptr;
+      vk::BufferViewCreateFlags flags;
+      vk::Buffer buffer;
+      vk::Format format;
+      vk::DeviceSize offset;
+      vk::DeviceSize range;
+    };
+    static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct BufferViewCreateInfo : public layout::BufferViewCreateInfo
+  {
+    BufferViewCreateInfo( vk::BufferViewCreateFlags flags_ = vk::BufferViewCreateFlags(),
+                          vk::Buffer buffer_ = vk::Buffer(),
+                          vk::Format format_ = vk::Format::eUndefined,
+                          vk::DeviceSize offset_ = 0,
+                          vk::DeviceSize range_ = 0 )
+      : layout::BufferViewCreateInfo( flags_, buffer_, format_, offset_, range_ )
     {}
 
     BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkBufferViewCreateInfo*>(this) = rhs;
-    }
+      : layout::BufferViewCreateInfo( rhs )
+    {}
 
     BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
     {
@@ -21190,31 +22679,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    BufferViewCreateInfo & setFlags( BufferViewCreateFlags flags_ )
+    BufferViewCreateInfo & setFlags( vk::BufferViewCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    BufferViewCreateInfo & setBuffer( Buffer buffer_ )
+    BufferViewCreateInfo & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
     }
 
-    BufferViewCreateInfo & setFormat( Format format_ )
+    BufferViewCreateInfo & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    BufferViewCreateInfo & setOffset( DeviceSize offset_ )
+    BufferViewCreateInfo & setOffset( vk::DeviceSize offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    BufferViewCreateInfo & setRange( DeviceSize range_ )
+    BufferViewCreateInfo & setRange( vk::DeviceSize range_ )
     {
       range = range_;
       return *this;
@@ -21247,28 +22736,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eBufferViewCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    BufferViewCreateFlags flags;
-    Buffer buffer;
-    Format format;
-    DeviceSize offset;
-    DeviceSize range;
+    using layout::BufferViewCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct CalibratedTimestampInfoEXT
+    {
+    protected:
+      CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice )
+        : timeDomain( timeDomain_ )
+      {}
 
-  struct CalibratedTimestampInfoEXT
+      CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this) = rhs;
+      }
+
+      CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
+      const void* pNext = nullptr;
+      vk::TimeDomainEXT timeDomain;
+    };
+    static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct CalibratedTimestampInfoEXT : public layout::CalibratedTimestampInfoEXT
   {
-    CalibratedTimestampInfoEXT( TimeDomainEXT timeDomain_ = TimeDomainEXT::eDevice )
-      : timeDomain( timeDomain_ )
+    CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice )
+      : layout::CalibratedTimestampInfoEXT( timeDomain_ )
     {}
 
     CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this) = rhs;
-    }
+      : layout::CalibratedTimestampInfoEXT( rhs )
+    {}
 
     CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs )
     {
@@ -21282,7 +22791,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CalibratedTimestampInfoEXT & setTimeDomain( TimeDomainEXT timeDomain_ )
+    CalibratedTimestampInfoEXT & setTimeDomain( vk::TimeDomainEXT timeDomain_ )
     {
       timeDomain = timeDomain_;
       return *this;
@@ -21311,15 +22820,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    TimeDomainEXT timeDomain;
+    using layout::CalibratedTimestampInfoEXT::sType;
   };
   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!" );
 
-  struct CheckpointDataNV
+  namespace layout
+  {
+    struct CheckpointDataNV
+    {
+    protected:
+      CheckpointDataNV( vk::PipelineStageFlagBits stage_ = vk::PipelineStageFlagBits::eTopOfPipe,
+                        void* pCheckpointMarker_ = nullptr )
+        : stage( stage_ )
+        , pCheckpointMarker( pCheckpointMarker_ )
+      {}
+
+      CheckpointDataNV( VkCheckpointDataNV const & rhs )
+      {
+        *reinterpret_cast<VkCheckpointDataNV*>(this) = rhs;
+      }
+
+      CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs )
+      {
+        *reinterpret_cast<VkCheckpointDataNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCheckpointDataNV;
+      void* pNext = nullptr;
+      vk::PipelineStageFlagBits stage;
+      void* pCheckpointMarker;
+    };
+    static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct CheckpointDataNV : public layout::CheckpointDataNV
   {
     operator VkCheckpointDataNV const&() const
     {
@@ -21345,14 +22882,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCheckpointDataNV;
-
-  public:
-    void* pNext = nullptr;
-    PipelineStageFlagBits stage;
-    void* pCheckpointMarker;
+    using layout::CheckpointDataNV::sType;
   };
   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!" );
 
   union ClearColorValue
   {
@@ -21371,7 +22904,6 @@ namespace VULKAN_HPP_NAMESPACE
       memcpy( uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
     }
 
-
     ClearColorValue & setFloat32( std::array<float,4> float32_ )
     {
       memcpy( float32, float32_.data(), 4 * sizeof( float ) );
@@ -21408,8 +22940,8 @@ namespace VULKAN_HPP_NAMESPACE
   {
     ClearDepthStencilValue( float depth_ = 0,
                             uint32_t stencil_ = 0 )
-      : depth( depth_ )
-      , stencil( stencil_ )
+        : depth( depth_ )
+        , stencil( stencil_ )
     {}
 
     ClearDepthStencilValue( VkClearDepthStencilValue const & rhs )
@@ -21456,31 +22988,32 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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!" );
 
   union ClearValue
   {
-    ClearValue( ClearColorValue color_ = ClearColorValue() )
+    ClearValue( vk::ClearColorValue color_ = vk::ClearColorValue() )
     {
       color = color_;
     }
 
-    ClearValue( ClearDepthStencilValue depthStencil_ )
+    ClearValue( vk::ClearDepthStencilValue depthStencil_ )
     {
       depthStencil = depthStencil_;
     }
 
-
-    ClearValue & setColor( ClearColorValue color_ )
+    ClearValue & setColor( vk::ClearColorValue color_ )
     {
       color = color_;
       return *this;
     }
 
-    ClearValue & setDepthStencil( ClearDepthStencilValue depthStencil_ )
+    ClearValue & setDepthStencil( vk::ClearDepthStencilValue depthStencil_ )
     {
       depthStencil = depthStencil_;
       return *this;
@@ -21496,8 +23029,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
 #ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-    ClearColorValue color;
-    ClearDepthStencilValue depthStencil;
+    vk::ClearColorValue color;
+    vk::ClearDepthStencilValue depthStencil;
 #else
     VkClearColorValue color;
     VkClearDepthStencilValue depthStencil;
@@ -21506,12 +23039,12 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ClearAttachment
   {
-    ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+    ClearAttachment( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
                      uint32_t colorAttachment_ = 0,
-                     ClearValue clearValue_ = ClearValue() )
-      : aspectMask( aspectMask_ )
-      , colorAttachment( colorAttachment_ )
-      , clearValue( clearValue_ )
+                     vk::ClearValue clearValue_ = vk::ClearValue() )
+        : aspectMask( aspectMask_ )
+        , colorAttachment( colorAttachment_ )
+        , clearValue( clearValue_ )
     {}
 
     ClearAttachment( VkClearAttachment const & rhs )
@@ -21525,7 +23058,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ClearAttachment & setAspectMask( ImageAspectFlags aspectMask_ )
+    ClearAttachment & setAspectMask( vk::ImageAspectFlags aspectMask_ )
     {
       aspectMask = aspectMask_;
       return *this;
@@ -21537,7 +23070,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ClearAttachment & setClearValue( ClearValue clearValue_ )
+    ClearAttachment & setClearValue( vk::ClearValue clearValue_ )
     {
       clearValue = clearValue_;
       return *this;
@@ -21553,20 +23086,22 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkClearAttachment*>( this );
     }
 
-    ImageAspectFlags aspectMask;
+  public:
+    vk::ImageAspectFlags aspectMask;
     uint32_t colorAttachment;
-    ClearValue clearValue;
+    vk::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
   {
-    ClearRect( Rect2D rect_ = Rect2D(),
+    ClearRect( vk::Rect2D rect_ = vk::Rect2D(),
                uint32_t baseArrayLayer_ = 0,
                uint32_t layerCount_ = 0 )
-      : rect( rect_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
+        : rect( rect_ )
+        , baseArrayLayer( baseArrayLayer_ )
+        , layerCount( layerCount_ )
     {}
 
     ClearRect( VkClearRect const & rhs )
@@ -21580,7 +23115,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ClearRect & setRect( Rect2D rect_ )
+    ClearRect & setRect( vk::Rect2D rect_ )
     {
       rect = rect_;
       return *this;
@@ -21620,20 +23155,22 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Rect2D rect;
+  public:
+    vk::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 IndirectCommandsTokenNVX
   {
-    IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
-                              Buffer buffer_ = Buffer(),
-                              DeviceSize offset_ = 0 )
-      : tokenType( tokenType_ )
-      , buffer( buffer_ )
-      , offset( offset_ )
+    IndirectCommandsTokenNVX( vk::IndirectCommandsTokenTypeNVX tokenType_ = vk::IndirectCommandsTokenTypeNVX::ePipeline,
+                              vk::Buffer buffer_ = vk::Buffer(),
+                              vk::DeviceSize offset_ = 0 )
+        : tokenType( tokenType_ )
+        , buffer( buffer_ )
+        , offset( offset_ )
     {}
 
     IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
@@ -21647,19 +23184,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    IndirectCommandsTokenNVX & setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+    IndirectCommandsTokenNVX & setTokenType( vk::IndirectCommandsTokenTypeNVX tokenType_ )
     {
       tokenType = tokenType_;
       return *this;
     }
 
-    IndirectCommandsTokenNVX & setBuffer( Buffer buffer_ )
+    IndirectCommandsTokenNVX & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
     }
 
-    IndirectCommandsTokenNVX & setOffset( DeviceSize offset_ )
+    IndirectCommandsTokenNVX & setOffset( vk::DeviceSize offset_ )
     {
       offset = offset_;
       return *this;
@@ -21687,40 +23224,87 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    IndirectCommandsTokenTypeNVX tokenType;
-    Buffer buffer;
-    DeviceSize offset;
+  public:
+    vk::IndirectCommandsTokenTypeNVX tokenType;
+    vk::Buffer buffer;
+    vk::DeviceSize offset;
   };
   static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<IndirectCommandsTokenNVX>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct CmdProcessCommandsInfoNVX
+    {
+    protected:
+      CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
+                                 vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
+                                 uint32_t indirectCommandsTokenCount_ = 0,
+                                 const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr,
+                                 uint32_t maxSequencesCount_ = 0,
+                                 vk::CommandBuffer targetCommandBuffer_ = vk::CommandBuffer(),
+                                 vk::Buffer sequencesCountBuffer_ = vk::Buffer(),
+                                 vk::DeviceSize sequencesCountOffset_ = 0,
+                                 vk::Buffer sequencesIndexBuffer_ = vk::Buffer(),
+                                 vk::DeviceSize sequencesIndexOffset_ = 0 )
+        : objectTable( objectTable_ )
+        , indirectCommandsLayout( indirectCommandsLayout_ )
+        , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
+        , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
+        , maxSequencesCount( maxSequencesCount_ )
+        , targetCommandBuffer( targetCommandBuffer_ )
+        , sequencesCountBuffer( sequencesCountBuffer_ )
+        , sequencesCountOffset( sequencesCountOffset_ )
+        , sequencesIndexBuffer( sequencesIndexBuffer_ )
+        , sequencesIndexOffset( sequencesIndexOffset_ )
+      {}
+
+      CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this) = rhs;
+      }
+
+      CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
+      const void* pNext = nullptr;
+      vk::ObjectTableNVX objectTable;
+      vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
+      uint32_t indirectCommandsTokenCount;
+      const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens;
+      uint32_t maxSequencesCount;
+      vk::CommandBuffer targetCommandBuffer;
+      vk::Buffer sequencesCountBuffer;
+      vk::DeviceSize sequencesCountOffset;
+      vk::Buffer sequencesIndexBuffer;
+      vk::DeviceSize sequencesIndexOffset;
+    };
+    static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "layout struct and wrapper have different size!" );
+  }
 
-  struct CmdProcessCommandsInfoNVX
+  struct CmdProcessCommandsInfoNVX : public layout::CmdProcessCommandsInfoNVX
   {
-    CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(),
-                               IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(),
+    CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
+                               vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
                                uint32_t indirectCommandsTokenCount_ = 0,
-                               const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr,
+                               const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr,
                                uint32_t maxSequencesCount_ = 0,
-                               CommandBuffer targetCommandBuffer_ = CommandBuffer(),
-                               Buffer sequencesCountBuffer_ = Buffer(),
-                               DeviceSize sequencesCountOffset_ = 0,
-                               Buffer sequencesIndexBuffer_ = Buffer(),
-                               DeviceSize sequencesIndexOffset_ = 0 )
-      : objectTable( objectTable_ )
-      , indirectCommandsLayout( indirectCommandsLayout_ )
-      , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
-      , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
-      , maxSequencesCount( maxSequencesCount_ )
-      , targetCommandBuffer( targetCommandBuffer_ )
-      , sequencesCountBuffer( sequencesCountBuffer_ )
-      , sequencesCountOffset( sequencesCountOffset_ )
-      , sequencesIndexBuffer( sequencesIndexBuffer_ )
-      , sequencesIndexOffset( sequencesIndexOffset_ )
+                               vk::CommandBuffer targetCommandBuffer_ = vk::CommandBuffer(),
+                               vk::Buffer sequencesCountBuffer_ = vk::Buffer(),
+                               vk::DeviceSize sequencesCountOffset_ = 0,
+                               vk::Buffer sequencesIndexBuffer_ = vk::Buffer(),
+                               vk::DeviceSize sequencesIndexOffset_ = 0 )
+      : layout::CmdProcessCommandsInfoNVX( objectTable_, indirectCommandsLayout_, indirectCommandsTokenCount_, pIndirectCommandsTokens_, maxSequencesCount_, targetCommandBuffer_, sequencesCountBuffer_, sequencesCountOffset_, sequencesIndexBuffer_, sequencesIndexOffset_ )
     {}
 
     CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
-    {
-      *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this) = rhs;
-    }
+      : layout::CmdProcessCommandsInfoNVX( rhs )
+    {}
 
     CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
     {
@@ -21734,13 +23318,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CmdProcessCommandsInfoNVX & setObjectTable( ObjectTableNVX objectTable_ )
+    CmdProcessCommandsInfoNVX & setObjectTable( vk::ObjectTableNVX objectTable_ )
     {
       objectTable = objectTable_;
       return *this;
     }
 
-    CmdProcessCommandsInfoNVX & setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
+    CmdProcessCommandsInfoNVX & setIndirectCommandsLayout( vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ )
     {
       indirectCommandsLayout = indirectCommandsLayout_;
       return *this;
@@ -21752,7 +23336,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CmdProcessCommandsInfoNVX & setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
+    CmdProcessCommandsInfoNVX & setPIndirectCommandsTokens( const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
     {
       pIndirectCommandsTokens = pIndirectCommandsTokens_;
       return *this;
@@ -21764,31 +23348,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CmdProcessCommandsInfoNVX & setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ )
+    CmdProcessCommandsInfoNVX & setTargetCommandBuffer( vk::CommandBuffer targetCommandBuffer_ )
     {
       targetCommandBuffer = targetCommandBuffer_;
       return *this;
     }
 
-    CmdProcessCommandsInfoNVX & setSequencesCountBuffer( Buffer sequencesCountBuffer_ )
+    CmdProcessCommandsInfoNVX & setSequencesCountBuffer( vk::Buffer sequencesCountBuffer_ )
     {
       sequencesCountBuffer = sequencesCountBuffer_;
       return *this;
     }
 
-    CmdProcessCommandsInfoNVX & setSequencesCountOffset( DeviceSize sequencesCountOffset_ )
+    CmdProcessCommandsInfoNVX & setSequencesCountOffset( vk::DeviceSize sequencesCountOffset_ )
     {
       sequencesCountOffset = sequencesCountOffset_;
       return *this;
     }
 
-    CmdProcessCommandsInfoNVX & setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ )
+    CmdProcessCommandsInfoNVX & setSequencesIndexBuffer( vk::Buffer sequencesIndexBuffer_ )
     {
       sequencesIndexBuffer = sequencesIndexBuffer_;
       return *this;
     }
 
-    CmdProcessCommandsInfoNVX & setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ )
+    CmdProcessCommandsInfoNVX & setSequencesIndexOffset( vk::DeviceSize sequencesIndexOffset_ )
     {
       sequencesIndexOffset = sequencesIndexOffset_;
       return *this;
@@ -21826,37 +23410,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectTableNVX objectTable;
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    uint32_t indirectCommandsTokenCount;
-    const IndirectCommandsTokenNVX* pIndirectCommandsTokens;
-    uint32_t maxSequencesCount;
-    CommandBuffer targetCommandBuffer;
-    Buffer sequencesCountBuffer;
-    DeviceSize sequencesCountOffset;
-    Buffer sequencesIndexBuffer;
-    DeviceSize sequencesIndexOffset;
+    using layout::CmdProcessCommandsInfoNVX::sType;
   };
   static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<CmdProcessCommandsInfoNVX>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct CmdReserveSpaceForCommandsInfoNVX
+    {
+    protected:
+      CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
+                                         vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
+                                         uint32_t maxSequencesCount_ = 0 )
+        : objectTable( objectTable_ )
+        , indirectCommandsLayout( indirectCommandsLayout_ )
+        , maxSequencesCount( maxSequencesCount_ )
+      {}
+
+      CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this) = rhs;
+      }
+
+      CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
+      const void* pNext = nullptr;
+      vk::ObjectTableNVX objectTable;
+      vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
+      uint32_t maxSequencesCount;
+    };
+    static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "layout struct and wrapper have different size!" );
+  }
 
-  struct CmdReserveSpaceForCommandsInfoNVX
+  struct CmdReserveSpaceForCommandsInfoNVX : public layout::CmdReserveSpaceForCommandsInfoNVX
   {
-    CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(),
-                                       IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(),
+    CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
+                                       vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
                                        uint32_t maxSequencesCount_ = 0 )
-      : objectTable( objectTable_ )
-      , indirectCommandsLayout( indirectCommandsLayout_ )
-      , maxSequencesCount( maxSequencesCount_ )
+      : layout::CmdReserveSpaceForCommandsInfoNVX( objectTable_, indirectCommandsLayout_, maxSequencesCount_ )
     {}
 
     CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
-    {
-      *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this) = rhs;
-    }
+      : layout::CmdReserveSpaceForCommandsInfoNVX( rhs )
+    {}
 
     CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
     {
@@ -21870,13 +23473,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CmdReserveSpaceForCommandsInfoNVX & setObjectTable( ObjectTableNVX objectTable_ )
+    CmdReserveSpaceForCommandsInfoNVX & setObjectTable( vk::ObjectTableNVX objectTable_ )
     {
       objectTable = objectTable_;
       return *this;
     }
 
-    CmdReserveSpaceForCommandsInfoNVX & setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
+    CmdReserveSpaceForCommandsInfoNVX & setIndirectCommandsLayout( vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ )
     {
       indirectCommandsLayout = indirectCommandsLayout_;
       return *this;
@@ -21913,24 +23516,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectTableNVX objectTable;
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    uint32_t maxSequencesCount;
+    using layout::CmdReserveSpaceForCommandsInfoNVX::sType;
   };
   static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<CmdReserveSpaceForCommandsInfoNVX>::value, "struct wrapper is not a standard layout!" );
 
   struct CoarseSampleLocationNV
   {
     CoarseSampleLocationNV( uint32_t pixelX_ = 0,
                             uint32_t pixelY_ = 0,
                             uint32_t sample_ = 0 )
-      : pixelX( pixelX_ )
-      , pixelY( pixelY_ )
-      , sample( sample_ )
+        : pixelX( pixelX_ )
+        , pixelY( pixelY_ )
+        , sample( sample_ )
     {}
 
     CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs )
@@ -21984,22 +23582,24 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
   {
-    CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations,
+    CoarseSampleOrderCustomNV( vk::ShadingRatePaletteEntryNV shadingRate_ = vk::ShadingRatePaletteEntryNV::eNoInvocations,
                                uint32_t sampleCount_ = 0,
                                uint32_t sampleLocationCount_ = 0,
-                               const CoarseSampleLocationNV* pSampleLocations_ = nullptr )
-      : shadingRate( shadingRate_ )
-      , sampleCount( sampleCount_ )
-      , sampleLocationCount( sampleLocationCount_ )
-      , pSampleLocations( pSampleLocations_ )
+                               const vk::CoarseSampleLocationNV* pSampleLocations_ = nullptr )
+        : shadingRate( shadingRate_ )
+        , sampleCount( sampleCount_ )
+        , sampleLocationCount( sampleLocationCount_ )
+        , pSampleLocations( pSampleLocations_ )
     {}
 
     CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs )
@@ -22013,7 +23613,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CoarseSampleOrderCustomNV & setShadingRate( ShadingRatePaletteEntryNV shadingRate_ )
+    CoarseSampleOrderCustomNV & setShadingRate( vk::ShadingRatePaletteEntryNV shadingRate_ )
     {
       shadingRate = shadingRate_;
       return *this;
@@ -22031,7 +23631,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CoarseSampleOrderCustomNV & setPSampleLocations( const CoarseSampleLocationNV* pSampleLocations_ )
+    CoarseSampleOrderCustomNV & setPSampleLocations( const vk::CoarseSampleLocationNV* pSampleLocations_ )
     {
       pSampleLocations = pSampleLocations_;
       return *this;
@@ -22060,27 +23660,60 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ShadingRatePaletteEntryNV shadingRate;
+  public:
+    vk::ShadingRatePaletteEntryNV shadingRate;
     uint32_t sampleCount;
     uint32_t sampleLocationCount;
-    const CoarseSampleLocationNV* pSampleLocations;
+    const vk::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
+  namespace layout
   {
-    CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(),
-                               CommandBufferLevel level_ = CommandBufferLevel::ePrimary,
+    struct CommandBufferAllocateInfo
+    {
+    protected:
+      CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(),
+                                 vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary,
+                                 uint32_t commandBufferCount_ = 0 )
+        : commandPool( commandPool_ )
+        , level( level_ )
+        , commandBufferCount( commandBufferCount_ )
+      {}
+
+      CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkCommandBufferAllocateInfo*>(this) = rhs;
+      }
+
+      CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkCommandBufferAllocateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCommandBufferAllocateInfo;
+      const void* pNext = nullptr;
+      vk::CommandPool commandPool;
+      vk::CommandBufferLevel level;
+      uint32_t commandBufferCount;
+    };
+    static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct CommandBufferAllocateInfo : public layout::CommandBufferAllocateInfo
+  {
+    CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(),
+                               vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary,
                                uint32_t commandBufferCount_ = 0 )
-      : commandPool( commandPool_ )
-      , level( level_ )
-      , commandBufferCount( commandBufferCount_ )
+      : layout::CommandBufferAllocateInfo( commandPool_, level_, commandBufferCount_ )
     {}
 
     CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
-    {
-      *reinterpret_cast<VkCommandBufferAllocateInfo*>(this) = rhs;
-    }
+      : layout::CommandBufferAllocateInfo( rhs )
+    {}
 
     CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
     {
@@ -22094,13 +23727,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CommandBufferAllocateInfo & setCommandPool( CommandPool commandPool_ )
+    CommandBufferAllocateInfo & setCommandPool( vk::CommandPool commandPool_ )
     {
       commandPool = commandPool_;
       return *this;
     }
 
-    CommandBufferAllocateInfo & setLevel( CommandBufferLevel level_ )
+    CommandBufferAllocateInfo & setLevel( vk::CommandBufferLevel level_ )
     {
       level = level_;
       return *this;
@@ -22137,36 +23770,68 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCommandBufferAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandPool commandPool;
-    CommandBufferLevel level;
-    uint32_t commandBufferCount;
+    using layout::CommandBufferAllocateInfo::sType;
   };
   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!" );
 
-  struct CommandBufferInheritanceInfo
+  namespace layout
   {
-    CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(),
+    struct CommandBufferInheritanceInfo
+    {
+    protected:
+      CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
+                                    uint32_t subpass_ = 0,
+                                    vk::Framebuffer framebuffer_ = vk::Framebuffer(),
+                                    vk::Bool32 occlusionQueryEnable_ = 0,
+                                    vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(),
+                                    vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() )
+        : renderPass( renderPass_ )
+        , subpass( subpass_ )
+        , framebuffer( framebuffer_ )
+        , occlusionQueryEnable( occlusionQueryEnable_ )
+        , queryFlags( queryFlags_ )
+        , pipelineStatistics( pipelineStatistics_ )
+      {}
+
+      CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
+      {
+        *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this) = rhs;
+      }
+
+      CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
+      {
+        *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCommandBufferInheritanceInfo;
+      const void* pNext = nullptr;
+      vk::RenderPass renderPass;
+      uint32_t subpass;
+      vk::Framebuffer framebuffer;
+      vk::Bool32 occlusionQueryEnable;
+      vk::QueryControlFlags queryFlags;
+      vk::QueryPipelineStatisticFlags pipelineStatistics;
+    };
+    static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct CommandBufferInheritanceInfo : public layout::CommandBufferInheritanceInfo
+  {
+    CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
                                   uint32_t subpass_ = 0,
-                                  Framebuffer framebuffer_ = Framebuffer(),
-                                  Bool32 occlusionQueryEnable_ = 0,
-                                  QueryControlFlags queryFlags_ = QueryControlFlags(),
-                                  QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
-      : renderPass( renderPass_ )
-      , subpass( subpass_ )
-      , framebuffer( framebuffer_ )
-      , occlusionQueryEnable( occlusionQueryEnable_ )
-      , queryFlags( queryFlags_ )
-      , pipelineStatistics( pipelineStatistics_ )
+                                  vk::Framebuffer framebuffer_ = vk::Framebuffer(),
+                                  vk::Bool32 occlusionQueryEnable_ = 0,
+                                  vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(),
+                                  vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() )
+      : layout::CommandBufferInheritanceInfo( renderPass_, subpass_, framebuffer_, occlusionQueryEnable_, queryFlags_, pipelineStatistics_ )
     {}
 
     CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
-    {
-      *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this) = rhs;
-    }
+      : layout::CommandBufferInheritanceInfo( rhs )
+    {}
 
     CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
     {
@@ -22180,7 +23845,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CommandBufferInheritanceInfo & setRenderPass( RenderPass renderPass_ )
+    CommandBufferInheritanceInfo & setRenderPass( vk::RenderPass renderPass_ )
     {
       renderPass = renderPass_;
       return *this;
@@ -22192,25 +23857,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CommandBufferInheritanceInfo & setFramebuffer( Framebuffer framebuffer_ )
+    CommandBufferInheritanceInfo & setFramebuffer( vk::Framebuffer framebuffer_ )
     {
       framebuffer = framebuffer_;
       return *this;
     }
 
-    CommandBufferInheritanceInfo & setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
+    CommandBufferInheritanceInfo & setOcclusionQueryEnable( vk::Bool32 occlusionQueryEnable_ )
     {
       occlusionQueryEnable = occlusionQueryEnable_;
       return *this;
     }
 
-    CommandBufferInheritanceInfo & setQueryFlags( QueryControlFlags queryFlags_ )
+    CommandBufferInheritanceInfo & setQueryFlags( vk::QueryControlFlags queryFlags_ )
     {
       queryFlags = queryFlags_;
       return *this;
     }
 
-    CommandBufferInheritanceInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+    CommandBufferInheritanceInfo & setPipelineStatistics( vk::QueryPipelineStatisticFlags pipelineStatistics_ )
     {
       pipelineStatistics = pipelineStatistics_;
       return *this;
@@ -22244,31 +23909,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCommandBufferInheritanceInfo;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPass renderPass;
-    uint32_t subpass;
-    Framebuffer framebuffer;
-    Bool32 occlusionQueryEnable;
-    QueryControlFlags queryFlags;
-    QueryPipelineStatisticFlags pipelineStatistics;
+    using layout::CommandBufferInheritanceInfo::sType;
   };
   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!" );
 
-  struct CommandBufferBeginInfo
+  namespace layout
   {
-    CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(),
-                            const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
-      : flags( flags_ )
-      , pInheritanceInfo( pInheritanceInfo_ )
+    struct CommandBufferBeginInfo
+    {
+    protected:
+      CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(),
+                              const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
+        : flags( flags_ )
+        , pInheritanceInfo( pInheritanceInfo_ )
+      {}
+
+      CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
+      {
+        *reinterpret_cast<VkCommandBufferBeginInfo*>(this) = rhs;
+      }
+
+      CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
+      {
+        *reinterpret_cast<VkCommandBufferBeginInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCommandBufferBeginInfo;
+      const void* pNext = nullptr;
+      vk::CommandBufferUsageFlags flags;
+      const vk::CommandBufferInheritanceInfo* pInheritanceInfo;
+    };
+    static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct CommandBufferBeginInfo : public layout::CommandBufferBeginInfo
+  {
+    CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(),
+                            const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
+      : layout::CommandBufferBeginInfo( flags_, pInheritanceInfo_ )
     {}
 
     CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
-    {
-      *reinterpret_cast<VkCommandBufferBeginInfo*>(this) = rhs;
-    }
+      : layout::CommandBufferBeginInfo( rhs )
+    {}
 
     CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
     {
@@ -22282,13 +23968,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CommandBufferBeginInfo & setFlags( CommandBufferUsageFlags flags_ )
+    CommandBufferBeginInfo & setFlags( vk::CommandBufferUsageFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    CommandBufferBeginInfo & setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
+    CommandBufferBeginInfo & setPInheritanceInfo( const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ )
     {
       pInheritanceInfo = pInheritanceInfo_;
       return *this;
@@ -22318,25 +24004,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCommandBufferBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandBufferUsageFlags flags;
-    const CommandBufferInheritanceInfo* pInheritanceInfo;
+    using layout::CommandBufferBeginInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct CommandBufferInheritanceConditionalRenderingInfoEXT
+    {
+    protected:
+      CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 )
+        : conditionalRenderingEnable( conditionalRenderingEnable_ )
+      {}
 
-  struct CommandBufferInheritanceConditionalRenderingInfoEXT
+      CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this) = rhs;
+      }
+
+      CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
+      const void* pNext = nullptr;
+      vk::Bool32 conditionalRenderingEnable;
+    };
+    static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct CommandBufferInheritanceConditionalRenderingInfoEXT : public layout::CommandBufferInheritanceConditionalRenderingInfoEXT
   {
-    CommandBufferInheritanceConditionalRenderingInfoEXT( Bool32 conditionalRenderingEnable_ = 0 )
-      : conditionalRenderingEnable( conditionalRenderingEnable_ )
+    CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 )
+      : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( conditionalRenderingEnable_ )
     {}
 
     CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this) = rhs;
-    }
+      : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( rhs )
+    {}
 
     CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
     {
@@ -22350,7 +24059,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ )
+    CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( vk::Bool32 conditionalRenderingEnable_ )
     {
       conditionalRenderingEnable = conditionalRenderingEnable_;
       return *this;
@@ -22379,26 +24088,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 conditionalRenderingEnable;
+    using layout::CommandBufferInheritanceConditionalRenderingInfoEXT::sType;
   };
   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!" );
 
-  struct CommandPoolCreateInfo
+  namespace layout
   {
-    CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(),
+    struct CommandPoolCreateInfo
+    {
+    protected:
+      CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(),
+                             uint32_t queueFamilyIndex_ = 0 )
+        : flags( flags_ )
+        , queueFamilyIndex( queueFamilyIndex_ )
+      {}
+
+      CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkCommandPoolCreateInfo*>(this) = rhs;
+      }
+
+      CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkCommandPoolCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCommandPoolCreateInfo;
+      const void* pNext = nullptr;
+      vk::CommandPoolCreateFlags flags;
+      uint32_t queueFamilyIndex;
+    };
+    static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct CommandPoolCreateInfo : public layout::CommandPoolCreateInfo
+  {
+    CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(),
                            uint32_t queueFamilyIndex_ = 0 )
-      : flags( flags_ )
-      , queueFamilyIndex( queueFamilyIndex_ )
+      : layout::CommandPoolCreateInfo( flags_, queueFamilyIndex_ )
     {}
 
     CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkCommandPoolCreateInfo*>(this) = rhs;
-    }
+      : layout::CommandPoolCreateInfo( rhs )
+    {}
 
     CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
     {
@@ -22412,7 +24147,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CommandPoolCreateInfo & setFlags( CommandPoolCreateFlags flags_ )
+    CommandPoolCreateInfo & setFlags( vk::CommandPoolCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -22448,23 +24183,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCommandPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandPoolCreateFlags flags;
-    uint32_t queueFamilyIndex;
+    using layout::CommandPoolCreateInfo::sType;
   };
   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!" );
 
   struct SpecializationMapEntry
   {
     SpecializationMapEntry( uint32_t constantID_ = 0,
                             uint32_t offset_ = 0,
                             size_t size_ = 0 )
-      : constantID( constantID_ )
-      , offset( offset_ )
-      , size( size_ )
+        : constantID( constantID_ )
+        , offset( offset_ )
+        , size( size_ )
     {}
 
     SpecializationMapEntry( VkSpecializationMapEntry const & rhs )
@@ -22518,22 +24249,24 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
   {
     SpecializationInfo( uint32_t mapEntryCount_ = 0,
-                        const SpecializationMapEntry* pMapEntries_ = nullptr,
+                        const vk::SpecializationMapEntry* pMapEntries_ = nullptr,
                         size_t dataSize_ = 0,
                         const void* pData_ = nullptr )
-      : mapEntryCount( mapEntryCount_ )
-      , pMapEntries( pMapEntries_ )
-      , dataSize( dataSize_ )
-      , pData( pData_ )
+        : mapEntryCount( mapEntryCount_ )
+        , pMapEntries( pMapEntries_ )
+        , dataSize( dataSize_ )
+        , pData( pData_ )
     {}
 
     SpecializationInfo( VkSpecializationInfo const & rhs )
@@ -22553,7 +24286,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SpecializationInfo & setPMapEntries( const SpecializationMapEntry* pMapEntries_ )
+    SpecializationInfo & setPMapEntries( const vk::SpecializationMapEntry* pMapEntries_ )
     {
       pMapEntries = pMapEntries_;
       return *this;
@@ -22594,31 +24327,68 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t mapEntryCount;
-    const SpecializationMapEntry* pMapEntries;
+    const vk::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!" );
+
+  namespace layout
+  {
+    struct PipelineShaderStageCreateInfo
+    {
+    protected:
+      PipelineShaderStageCreateInfo( vk::PipelineShaderStageCreateFlags flags_ = vk::PipelineShaderStageCreateFlags(),
+                                     vk::ShaderStageFlagBits stage_ = vk::ShaderStageFlagBits::eVertex,
+                                     vk::ShaderModule module_ = vk::ShaderModule(),
+                                     const char* pName_ = nullptr,
+                                     const vk::SpecializationInfo* pSpecializationInfo_ = nullptr )
+        : flags( flags_ )
+        , stage( stage_ )
+        , module( module_ )
+        , pName( pName_ )
+        , pSpecializationInfo( pSpecializationInfo_ )
+      {}
+
+      PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this) = rhs;
+      }
+
+      PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineShaderStageCreateFlags flags;
+      vk::ShaderStageFlagBits stage;
+      vk::ShaderModule module;
+      const char* pName;
+      const vk::SpecializationInfo* pSpecializationInfo;
+    };
+    static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineShaderStageCreateInfo
+  struct PipelineShaderStageCreateInfo : public layout::PipelineShaderStageCreateInfo
   {
-    PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(),
-                                   ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex,
-                                   ShaderModule module_ = ShaderModule(),
+    PipelineShaderStageCreateInfo( vk::PipelineShaderStageCreateFlags flags_ = vk::PipelineShaderStageCreateFlags(),
+                                   vk::ShaderStageFlagBits stage_ = vk::ShaderStageFlagBits::eVertex,
+                                   vk::ShaderModule module_ = vk::ShaderModule(),
                                    const char* pName_ = nullptr,
-                                   const SpecializationInfo* pSpecializationInfo_ = nullptr )
-      : flags( flags_ )
-      , stage( stage_ )
-      , module( module_ )
-      , pName( pName_ )
-      , pSpecializationInfo( pSpecializationInfo_ )
+                                   const vk::SpecializationInfo* pSpecializationInfo_ = nullptr )
+      : layout::PipelineShaderStageCreateInfo( flags_, stage_, module_, pName_, pSpecializationInfo_ )
     {}
 
     PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineShaderStageCreateInfo( rhs )
+    {}
 
     PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
     {
@@ -22632,19 +24402,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineShaderStageCreateInfo & setFlags( PipelineShaderStageCreateFlags flags_ )
+    PipelineShaderStageCreateInfo & setFlags( vk::PipelineShaderStageCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineShaderStageCreateInfo & setStage( ShaderStageFlagBits stage_ )
+    PipelineShaderStageCreateInfo & setStage( vk::ShaderStageFlagBits stage_ )
     {
       stage = stage_;
       return *this;
     }
 
-    PipelineShaderStageCreateInfo & setModule( ShaderModule module_ )
+    PipelineShaderStageCreateInfo & setModule( vk::ShaderModule module_ )
     {
       module = module_;
       return *this;
@@ -22656,7 +24426,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineShaderStageCreateInfo & setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
+    PipelineShaderStageCreateInfo & setPSpecializationInfo( const vk::SpecializationInfo* pSpecializationInfo_ )
     {
       pSpecializationInfo = pSpecializationInfo_;
       return *this;
@@ -22689,36 +24459,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineShaderStageCreateFlags flags;
-    ShaderStageFlagBits stage;
-    ShaderModule module;
-    const char* pName;
-    const SpecializationInfo* pSpecializationInfo;
+    using layout::PipelineShaderStageCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ComputePipelineCreateInfo
+    {
+    protected:
+      ComputePipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+                                 vk::PipelineShaderStageCreateInfo stage_ = vk::PipelineShaderStageCreateInfo(),
+                                 vk::PipelineLayout layout_ = vk::PipelineLayout(),
+                                 vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+                                 int32_t basePipelineIndex_ = 0 )
+        : flags( flags_ )
+        , stage( stage_ )
+        , layout( layout_ )
+        , basePipelineHandle( basePipelineHandle_ )
+        , basePipelineIndex( basePipelineIndex_ )
+      {}
+
+      ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkComputePipelineCreateInfo*>(this) = rhs;
+      }
 
-  struct ComputePipelineCreateInfo
+      ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkComputePipelineCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eComputePipelineCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineCreateFlags flags;
+      vk::PipelineShaderStageCreateInfo stage;
+      vk::PipelineLayout layout;
+      vk::Pipeline basePipelineHandle;
+      int32_t basePipelineIndex;
+    };
+    static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ComputePipelineCreateInfo : public layout::ComputePipelineCreateInfo
   {
-    ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
-                               PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(),
-                               PipelineLayout layout_ = PipelineLayout(),
-                               Pipeline basePipelineHandle_ = Pipeline(),
+    ComputePipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+                               vk::PipelineShaderStageCreateInfo stage_ = vk::PipelineShaderStageCreateInfo(),
+                               vk::PipelineLayout layout_ = vk::PipelineLayout(),
+                               vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
                                int32_t basePipelineIndex_ = 0 )
-      : flags( flags_ )
-      , stage( stage_ )
-      , layout( layout_ )
-      , basePipelineHandle( basePipelineHandle_ )
-      , basePipelineIndex( basePipelineIndex_ )
+      : layout::ComputePipelineCreateInfo( flags_, stage_, layout_, basePipelineHandle_, basePipelineIndex_ )
     {}
 
     ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkComputePipelineCreateInfo*>(this) = rhs;
-    }
+      : layout::ComputePipelineCreateInfo( rhs )
+    {}
 
     ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
     {
@@ -22732,25 +24530,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ComputePipelineCreateInfo & setFlags( PipelineCreateFlags flags_ )
+    ComputePipelineCreateInfo & setFlags( vk::PipelineCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ComputePipelineCreateInfo & setStage( PipelineShaderStageCreateInfo stage_ )
+    ComputePipelineCreateInfo & setStage( vk::PipelineShaderStageCreateInfo stage_ )
     {
       stage = stage_;
       return *this;
     }
 
-    ComputePipelineCreateInfo & setLayout( PipelineLayout layout_ )
+    ComputePipelineCreateInfo & setLayout( vk::PipelineLayout layout_ )
     {
       layout = layout_;
       return *this;
     }
 
-    ComputePipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+    ComputePipelineCreateInfo & setBasePipelineHandle( vk::Pipeline basePipelineHandle_ )
     {
       basePipelineHandle = basePipelineHandle_;
       return *this;
@@ -22789,32 +24587,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eComputePipelineCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCreateFlags flags;
-    PipelineShaderStageCreateInfo stage;
-    PipelineLayout layout;
-    Pipeline basePipelineHandle;
-    int32_t basePipelineIndex;
+    using layout::ComputePipelineCreateInfo::sType;
   };
   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!" );
 
-  struct ConditionalRenderingBeginInfoEXT
+  namespace layout
   {
-    ConditionalRenderingBeginInfoEXT( Buffer buffer_ = Buffer(),
-                                      DeviceSize offset_ = 0,
-                                      ConditionalRenderingFlagsEXT flags_ = ConditionalRenderingFlagsEXT() )
-      : buffer( buffer_ )
-      , offset( offset_ )
-      , flags( flags_ )
+    struct ConditionalRenderingBeginInfoEXT
+    {
+    protected:
+      ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(),
+                                        vk::DeviceSize offset_ = 0,
+                                        vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() )
+        : buffer( buffer_ )
+        , offset( offset_ )
+        , flags( flags_ )
+      {}
+
+      ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this) = rhs;
+      }
+
+      ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
+      const void* pNext = nullptr;
+      vk::Buffer buffer;
+      vk::DeviceSize offset;
+      vk::ConditionalRenderingFlagsEXT flags;
+    };
+    static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ConditionalRenderingBeginInfoEXT : public layout::ConditionalRenderingBeginInfoEXT
+  {
+    ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(),
+                                      vk::DeviceSize offset_ = 0,
+                                      vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() )
+      : layout::ConditionalRenderingBeginInfoEXT( buffer_, offset_, flags_ )
     {}
 
     ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this) = rhs;
-    }
+      : layout::ConditionalRenderingBeginInfoEXT( rhs )
+    {}
 
     ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs )
     {
@@ -22828,19 +24650,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ConditionalRenderingBeginInfoEXT & setBuffer( Buffer buffer_ )
+    ConditionalRenderingBeginInfoEXT & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
     }
 
-    ConditionalRenderingBeginInfoEXT & setOffset( DeviceSize offset_ )
+    ConditionalRenderingBeginInfoEXT & setOffset( vk::DeviceSize offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    ConditionalRenderingBeginInfoEXT & setFlags( ConditionalRenderingFlagsEXT flags_ )
+    ConditionalRenderingBeginInfoEXT & setFlags( vk::ConditionalRenderingFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
@@ -22871,15 +24693,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer buffer;
-    DeviceSize offset;
-    ConditionalRenderingFlagsEXT flags;
+    using layout::ConditionalRenderingBeginInfoEXT::sType;
   };
   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!" );
 
   struct ConformanceVersionKHR
   {
@@ -22887,10 +24704,10 @@ namespace VULKAN_HPP_NAMESPACE
                            uint8_t minor_ = 0,
                            uint8_t subminor_ = 0,
                            uint8_t patch_ = 0 )
-      : major( major_ )
-      , minor( minor_ )
-      , subminor( subminor_ )
-      , patch( patch_ )
+        : major( major_ )
+        , minor( minor_ )
+        , subminor( subminor_ )
+        , patch( patch_ )
     {}
 
     ConformanceVersionKHR( VkConformanceVersionKHR const & rhs )
@@ -22951,37 +24768,80 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint8_t major;
     uint8_t minor;
     uint8_t subminor;
     uint8_t patch;
   };
   static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ConformanceVersionKHR>::value, "struct wrapper is not a standard layout!" );
 
-  struct CooperativeMatrixPropertiesNV
+  namespace layout
+  {
+    struct CooperativeMatrixPropertiesNV
+    {
+    protected:
+      CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0,
+                                     uint32_t NSize_ = 0,
+                                     uint32_t KSize_ = 0,
+                                     vk::ComponentTypeNV AType_ = vk::ComponentTypeNV::eFloat16,
+                                     vk::ComponentTypeNV BType_ = vk::ComponentTypeNV::eFloat16,
+                                     vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16,
+                                     vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16,
+                                     vk::ScopeNV scope_ = vk::ScopeNV::eDevice )
+        : MSize( MSize_ )
+        , NSize( NSize_ )
+        , KSize( KSize_ )
+        , AType( AType_ )
+        , BType( BType_ )
+        , CType( CType_ )
+        , DType( DType_ )
+        , scope( scope_ )
+      {}
+
+      CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(this) = rhs;
+      }
+
+      CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCooperativeMatrixPropertiesNV;
+      void* pNext = nullptr;
+      uint32_t MSize;
+      uint32_t NSize;
+      uint32_t KSize;
+      vk::ComponentTypeNV AType;
+      vk::ComponentTypeNV BType;
+      vk::ComponentTypeNV CType;
+      vk::ComponentTypeNV DType;
+      vk::ScopeNV scope;
+    };
+    static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct CooperativeMatrixPropertiesNV : public layout::CooperativeMatrixPropertiesNV
   {
     CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0,
                                    uint32_t NSize_ = 0,
                                    uint32_t KSize_ = 0,
-                                   ComponentTypeNV AType_ = ComponentTypeNV::eFloat16,
-                                   ComponentTypeNV BType_ = ComponentTypeNV::eFloat16,
-                                   ComponentTypeNV CType_ = ComponentTypeNV::eFloat16,
-                                   ComponentTypeNV DType_ = ComponentTypeNV::eFloat16,
-                                   ScopeNV scope_ = ScopeNV::eDevice )
-      : MSize( MSize_ )
-      , NSize( NSize_ )
-      , KSize( KSize_ )
-      , AType( AType_ )
-      , BType( BType_ )
-      , CType( CType_ )
-      , DType( DType_ )
-      , scope( scope_ )
+                                   vk::ComponentTypeNV AType_ = vk::ComponentTypeNV::eFloat16,
+                                   vk::ComponentTypeNV BType_ = vk::ComponentTypeNV::eFloat16,
+                                   vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16,
+                                   vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16,
+                                   vk::ScopeNV scope_ = vk::ScopeNV::eDevice )
+      : layout::CooperativeMatrixPropertiesNV( MSize_, NSize_, KSize_, AType_, BType_, CType_, DType_, scope_ )
     {}
 
     CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs )
-    {
-      *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(this) = rhs;
-    }
+      : layout::CooperativeMatrixPropertiesNV( rhs )
+    {}
 
     CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs )
     {
@@ -23013,31 +24873,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CooperativeMatrixPropertiesNV & setAType( ComponentTypeNV AType_ )
+    CooperativeMatrixPropertiesNV & setAType( vk::ComponentTypeNV AType_ )
     {
       AType = AType_;
       return *this;
     }
 
-    CooperativeMatrixPropertiesNV & setBType( ComponentTypeNV BType_ )
+    CooperativeMatrixPropertiesNV & setBType( vk::ComponentTypeNV BType_ )
     {
       BType = BType_;
       return *this;
     }
 
-    CooperativeMatrixPropertiesNV & setCType( ComponentTypeNV CType_ )
+    CooperativeMatrixPropertiesNV & setCType( vk::ComponentTypeNV CType_ )
     {
       CType = CType_;
       return *this;
     }
 
-    CooperativeMatrixPropertiesNV & setDType( ComponentTypeNV DType_ )
+    CooperativeMatrixPropertiesNV & setDType( vk::ComponentTypeNV DType_ )
     {
       DType = DType_;
       return *this;
     }
 
-    CooperativeMatrixPropertiesNV & setScope( ScopeNV scope_ )
+    CooperativeMatrixPropertiesNV & setScope( vk::ScopeNV scope_ )
     {
       scope = scope_;
       return *this;
@@ -23073,43 +24933,72 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCooperativeMatrixPropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t MSize;
-    uint32_t NSize;
-    uint32_t KSize;
-    ComponentTypeNV AType;
-    ComponentTypeNV BType;
-    ComponentTypeNV CType;
-    ComponentTypeNV DType;
-    ScopeNV scope;
+    using layout::CooperativeMatrixPropertiesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct CopyDescriptorSet
+    {
+    protected:
+      CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(),
+                         uint32_t srcBinding_ = 0,
+                         uint32_t srcArrayElement_ = 0,
+                         vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
+                         uint32_t dstBinding_ = 0,
+                         uint32_t dstArrayElement_ = 0,
+                         uint32_t descriptorCount_ = 0 )
+        : srcSet( srcSet_ )
+        , srcBinding( srcBinding_ )
+        , srcArrayElement( srcArrayElement_ )
+        , dstSet( dstSet_ )
+        , dstBinding( dstBinding_ )
+        , dstArrayElement( dstArrayElement_ )
+        , descriptorCount( descriptorCount_ )
+      {}
+
+      CopyDescriptorSet( VkCopyDescriptorSet const & rhs )
+      {
+        *reinterpret_cast<VkCopyDescriptorSet*>(this) = rhs;
+      }
+
+      CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs )
+      {
+        *reinterpret_cast<VkCopyDescriptorSet*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eCopyDescriptorSet;
+      const void* pNext = nullptr;
+      vk::DescriptorSet srcSet;
+      uint32_t srcBinding;
+      uint32_t srcArrayElement;
+      vk::DescriptorSet dstSet;
+      uint32_t dstBinding;
+      uint32_t dstArrayElement;
+      uint32_t descriptorCount;
+    };
+    static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "layout struct and wrapper have different size!" );
+  }
 
-  struct CopyDescriptorSet
+  struct CopyDescriptorSet : public layout::CopyDescriptorSet
   {
-    CopyDescriptorSet( DescriptorSet srcSet_ = DescriptorSet(),
+    CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(),
                        uint32_t srcBinding_ = 0,
                        uint32_t srcArrayElement_ = 0,
-                       DescriptorSet dstSet_ = DescriptorSet(),
+                       vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
                        uint32_t dstBinding_ = 0,
                        uint32_t dstArrayElement_ = 0,
                        uint32_t descriptorCount_ = 0 )
-      : srcSet( srcSet_ )
-      , srcBinding( srcBinding_ )
-      , srcArrayElement( srcArrayElement_ )
-      , dstSet( dstSet_ )
-      , dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
+      : layout::CopyDescriptorSet( srcSet_, srcBinding_, srcArrayElement_, dstSet_, dstBinding_, dstArrayElement_, descriptorCount_ )
     {}
 
     CopyDescriptorSet( VkCopyDescriptorSet const & rhs )
-    {
-      *reinterpret_cast<VkCopyDescriptorSet*>(this) = rhs;
-    }
+      : layout::CopyDescriptorSet( rhs )
+    {}
 
     CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs )
     {
@@ -23123,7 +25012,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CopyDescriptorSet & setSrcSet( DescriptorSet srcSet_ )
+    CopyDescriptorSet & setSrcSet( vk::DescriptorSet srcSet_ )
     {
       srcSet = srcSet_;
       return *this;
@@ -23141,7 +25030,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    CopyDescriptorSet & setDstSet( DescriptorSet dstSet_ )
+    CopyDescriptorSet & setDstSet( vk::DescriptorSet dstSet_ )
     {
       dstSet = dstSet_;
       return *this;
@@ -23194,37 +25083,62 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eCopyDescriptorSet;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorSet srcSet;
-    uint32_t srcBinding;
-    uint32_t srcArrayElement;
-    DescriptorSet dstSet;
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
+    using layout::CopyDescriptorSet::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct D3D12FenceSubmitInfoKHR
+
+  namespace layout
+  {
+    struct D3D12FenceSubmitInfoKHR
+    {
+    protected:
+      D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
+                               const uint64_t* pWaitSemaphoreValues_ = nullptr,
+                               uint32_t signalSemaphoreValuesCount_ = 0,
+                               const uint64_t* pSignalSemaphoreValues_ = nullptr )
+        : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
+        , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
+        , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
+        , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
+      {}
+
+      D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this) = rhs;
+      }
+
+      D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
+      const void* pNext = nullptr;
+      uint32_t waitSemaphoreValuesCount;
+      const uint64_t* pWaitSemaphoreValues;
+      uint32_t signalSemaphoreValuesCount;
+      const uint64_t* pSignalSemaphoreValues;
+    };
+    static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct D3D12FenceSubmitInfoKHR : public layout::D3D12FenceSubmitInfoKHR
   {
     D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
                              const uint64_t* pWaitSemaphoreValues_ = nullptr,
                              uint32_t signalSemaphoreValuesCount_ = 0,
                              const uint64_t* pSignalSemaphoreValues_ = nullptr )
-      : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
-      , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
-      , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
-      , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
+      : layout::D3D12FenceSubmitInfoKHR( waitSemaphoreValuesCount_, pWaitSemaphoreValues_, signalSemaphoreValuesCount_, pSignalSemaphoreValues_ )
     {}
 
     D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this) = rhs;
-    }
+      : layout::D3D12FenceSubmitInfoKHR( rhs )
+    {}
 
     D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs )
     {
@@ -23288,31 +25202,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreValuesCount;
-    const uint64_t* pWaitSemaphoreValues;
-    uint32_t signalSemaphoreValuesCount;
-    const uint64_t* pSignalSemaphoreValues;
+    using layout::D3D12FenceSubmitInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct DebugMarkerMarkerInfoEXT
+  namespace layout
+  {
+    struct DebugMarkerMarkerInfoEXT
+    {
+    protected:
+      DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
+                                std::array<float,4> const& color_ = { { 0 } } )
+        : pMarkerName( pMarkerName_ )
+      {
+        memcpy( &color, color_.data(), 4 * sizeof( float ) );
+      
+      }
+
+      DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this) = rhs;
+      }
+
+      DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
+      const void* pNext = nullptr;
+      const char* pMarkerName;
+      float color[4];
+    };
+    static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DebugMarkerMarkerInfoEXT : public layout::DebugMarkerMarkerInfoEXT
   {
     DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
                               std::array<float,4> const& color_ = { { 0 } } )
-      : pMarkerName( pMarkerName_ )
-    {
-      memcpy( &color, color_.data(), 4 * sizeof( float ) );
-    }
+      : layout::DebugMarkerMarkerInfoEXT( pMarkerName_, color_ )
+    {}
 
     DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this) = rhs;
-    }
+      : layout::DebugMarkerMarkerInfoEXT( rhs )
+    {}
 
     DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
     {
@@ -23362,29 +25300,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    const char* pMarkerName;
-    float color[4];
+    using layout::DebugMarkerMarkerInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DebugMarkerObjectNameInfoEXT
+    {
+    protected:
+      DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
+                                    uint64_t object_ = 0,
+                                    const char* pObjectName_ = nullptr )
+        : objectType( objectType_ )
+        , object( object_ )
+        , pObjectName( pObjectName_ )
+      {}
+
+      DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this) = rhs;
+      }
+
+      DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct DebugMarkerObjectNameInfoEXT
+    public:
+      vk::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
+      const void* pNext = nullptr;
+      vk::DebugReportObjectTypeEXT objectType;
+      uint64_t object;
+      const char* pObjectName;
+    };
+    static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DebugMarkerObjectNameInfoEXT : public layout::DebugMarkerObjectNameInfoEXT
   {
-    DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
+    DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
                                   uint64_t object_ = 0,
                                   const char* pObjectName_ = nullptr )
-      : objectType( objectType_ )
-      , object( object_ )
-      , pObjectName( pObjectName_ )
+      : layout::DebugMarkerObjectNameInfoEXT( objectType_, object_, pObjectName_ )
     {}
 
     DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this) = rhs;
-    }
+      : layout::DebugMarkerObjectNameInfoEXT( rhs )
+    {}
 
     DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
     {
@@ -23398,7 +25363,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugMarkerObjectNameInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ )
+    DebugMarkerObjectNameInfoEXT & setObjectType( vk::DebugReportObjectTypeEXT objectType_ )
     {
       objectType = objectType_;
       return *this;
@@ -23441,34 +25406,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportObjectTypeEXT objectType;
-    uint64_t object;
-    const char* pObjectName;
+    using layout::DebugMarkerObjectNameInfoEXT::sType;
   };
   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!" );
 
-  struct DebugMarkerObjectTagInfoEXT
+  namespace layout
   {
-    DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
+    struct DebugMarkerObjectTagInfoEXT
+    {
+    protected:
+      DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
+                                   uint64_t object_ = 0,
+                                   uint64_t tagName_ = 0,
+                                   size_t tagSize_ = 0,
+                                   const void* pTag_ = nullptr )
+        : objectType( objectType_ )
+        , object( object_ )
+        , tagName( tagName_ )
+        , tagSize( tagSize_ )
+        , pTag( pTag_ )
+      {}
+
+      DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this) = rhs;
+      }
+
+      DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
+      const void* pNext = nullptr;
+      vk::DebugReportObjectTypeEXT objectType;
+      uint64_t object;
+      uint64_t tagName;
+      size_t tagSize;
+      const void* pTag;
+    };
+    static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DebugMarkerObjectTagInfoEXT : public layout::DebugMarkerObjectTagInfoEXT
+  {
+    DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
                                  uint64_t object_ = 0,
                                  uint64_t tagName_ = 0,
                                  size_t tagSize_ = 0,
                                  const void* pTag_ = nullptr )
-      : objectType( objectType_ )
-      , object( object_ )
-      , tagName( tagName_ )
-      , tagSize( tagSize_ )
-      , pTag( pTag_ )
+      : layout::DebugMarkerObjectTagInfoEXT( objectType_, object_, tagName_, tagSize_, pTag_ )
     {}
 
     DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this) = rhs;
-    }
+      : layout::DebugMarkerObjectTagInfoEXT( rhs )
+    {}
 
     DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
     {
@@ -23482,7 +25477,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugMarkerObjectTagInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ )
+    DebugMarkerObjectTagInfoEXT & setObjectType( vk::DebugReportObjectTypeEXT objectType_ )
     {
       objectType = objectType_;
       return *this;
@@ -23539,32 +25534,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportObjectTypeEXT objectType;
-    uint64_t object;
-    uint64_t tagName;
-    size_t tagSize;
-    const void* pTag;
+    using layout::DebugMarkerObjectTagInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DebugReportCallbackCreateInfoEXT
+    {
+    protected:
+      DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(),
+                                        PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
+                                        void* pUserData_ = nullptr )
+        : flags( flags_ )
+        , pfnCallback( pfnCallback_ )
+        , pUserData( pUserData_ )
+      {}
 
-  struct DebugReportCallbackCreateInfoEXT
+      DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this) = rhs;
+      }
+
+      DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::DebugReportFlagsEXT flags;
+      PFN_vkDebugReportCallbackEXT pfnCallback;
+      void* pUserData;
+    };
+    static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DebugReportCallbackCreateInfoEXT : public layout::DebugReportCallbackCreateInfoEXT
   {
-    DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(),
+    DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(),
                                       PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
                                       void* pUserData_ = nullptr )
-      : flags( flags_ )
-      , pfnCallback( pfnCallback_ )
-      , pUserData( pUserData_ )
+      : layout::DebugReportCallbackCreateInfoEXT( flags_, pfnCallback_, pUserData_ )
     {}
 
     DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::DebugReportCallbackCreateInfoEXT( rhs )
+    {}
 
     DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
     {
@@ -23578,7 +25597,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugReportCallbackCreateInfoEXT & setFlags( DebugReportFlagsEXT flags_ )
+    DebugReportCallbackCreateInfoEXT & setFlags( vk::DebugReportFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
@@ -23621,29 +25640,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportFlagsEXT flags;
-    PFN_vkDebugReportCallbackEXT pfnCallback;
-    void* pUserData;
+    using layout::DebugReportCallbackCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DebugUtilsLabelEXT
+    {
+    protected:
+      DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
+                          std::array<float,4> const& color_ = { { 0 } } )
+        : pLabelName( pLabelName_ )
+      {
+        memcpy( &color, color_.data(), 4 * sizeof( float ) );
+      
+      }
+
+      DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsLabelEXT*>(this) = rhs;
+      }
+
+      DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsLabelEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDebugUtilsLabelEXT;
+      const void* pNext = nullptr;
+      const char* pLabelName;
+      float color[4];
+    };
+    static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DebugUtilsLabelEXT
+  struct DebugUtilsLabelEXT : public layout::DebugUtilsLabelEXT
   {
     DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
                         std::array<float,4> const& color_ = { { 0 } } )
-      : pLabelName( pLabelName_ )
-    {
-      memcpy( &color, color_.data(), 4 * sizeof( float ) );
-    }
+      : layout::DebugUtilsLabelEXT( pLabelName_, color_ )
+    {}
 
     DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugUtilsLabelEXT*>(this) = rhs;
-    }
+      : layout::DebugUtilsLabelEXT( rhs )
+    {}
 
     DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs )
     {
@@ -23693,29 +25737,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugUtilsLabelEXT;
-
-  public:
-    const void* pNext = nullptr;
-    const char* pLabelName;
-    float color[4];
+    using layout::DebugUtilsLabelEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DebugUtilsObjectNameInfoEXT
+    {
+    protected:
+      DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
+                                   uint64_t objectHandle_ = 0,
+                                   const char* pObjectName_ = nullptr )
+        : objectType( objectType_ )
+        , objectHandle( objectHandle_ )
+        , pObjectName( pObjectName_ )
+      {}
 
-  struct DebugUtilsObjectNameInfoEXT
+      DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this) = rhs;
+      }
+
+      DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
+      const void* pNext = nullptr;
+      vk::ObjectType objectType;
+      uint64_t objectHandle;
+      const char* pObjectName;
+    };
+    static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DebugUtilsObjectNameInfoEXT : public layout::DebugUtilsObjectNameInfoEXT
   {
-    DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
+    DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
                                  uint64_t objectHandle_ = 0,
                                  const char* pObjectName_ = nullptr )
-      : objectType( objectType_ )
-      , objectHandle( objectHandle_ )
-      , pObjectName( pObjectName_ )
+      : layout::DebugUtilsObjectNameInfoEXT( objectType_, objectHandle_, pObjectName_ )
     {}
 
     DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this) = rhs;
-    }
+      : layout::DebugUtilsObjectNameInfoEXT( rhs )
+    {}
 
     DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
     {
@@ -23729,7 +25800,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugUtilsObjectNameInfoEXT & setObjectType( ObjectType objectType_ )
+    DebugUtilsObjectNameInfoEXT & setObjectType( vk::ObjectType objectType_ )
     {
       objectType = objectType_;
       return *this;
@@ -23772,44 +25843,84 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectType objectType;
-    uint64_t objectHandle;
-    const char* pObjectName;
+    using layout::DebugUtilsObjectNameInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DebugUtilsMessengerCallbackDataEXT
+    {
+    protected:
+      DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(),
+                                          const char* pMessageIdName_ = nullptr,
+                                          int32_t messageIdNumber_ = 0,
+                                          const char* pMessage_ = nullptr,
+                                          uint32_t queueLabelCount_ = 0,
+                                          const vk::DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
+                                          uint32_t cmdBufLabelCount_ = 0,
+                                          const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
+                                          uint32_t objectCount_ = 0,
+                                          const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
+        : flags( flags_ )
+        , pMessageIdName( pMessageIdName_ )
+        , messageIdNumber( messageIdNumber_ )
+        , pMessage( pMessage_ )
+        , queueLabelCount( queueLabelCount_ )
+        , pQueueLabels( pQueueLabels_ )
+        , cmdBufLabelCount( cmdBufLabelCount_ )
+        , pCmdBufLabels( pCmdBufLabels_ )
+        , objectCount( objectCount_ )
+        , pObjects( pObjects_ )
+      {}
 
-  struct DebugUtilsMessengerCallbackDataEXT
+      DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this) = rhs;
+      }
+
+      DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
+      const void* pNext = nullptr;
+      vk::DebugUtilsMessengerCallbackDataFlagsEXT flags;
+      const char* pMessageIdName;
+      int32_t messageIdNumber;
+      const char* pMessage;
+      uint32_t queueLabelCount;
+      const vk::DebugUtilsLabelEXT* pQueueLabels;
+      uint32_t cmdBufLabelCount;
+      const vk::DebugUtilsLabelEXT* pCmdBufLabels;
+      uint32_t objectCount;
+      const vk::DebugUtilsObjectNameInfoEXT* pObjects;
+    };
+    static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DebugUtilsMessengerCallbackDataEXT : public layout::DebugUtilsMessengerCallbackDataEXT
   {
-    DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(),
+    DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(),
                                         const char* pMessageIdName_ = nullptr,
                                         int32_t messageIdNumber_ = 0,
                                         const char* pMessage_ = nullptr,
                                         uint32_t queueLabelCount_ = 0,
-                                        const DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
+                                        const vk::DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
                                         uint32_t cmdBufLabelCount_ = 0,
-                                        const DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
+                                        const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
                                         uint32_t objectCount_ = 0,
-                                        const DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
-      : flags( flags_ )
-      , pMessageIdName( pMessageIdName_ )
-      , messageIdNumber( messageIdNumber_ )
-      , pMessage( pMessage_ )
-      , queueLabelCount( queueLabelCount_ )
-      , pQueueLabels( pQueueLabels_ )
-      , cmdBufLabelCount( cmdBufLabelCount_ )
-      , pCmdBufLabels( pCmdBufLabels_ )
-      , objectCount( objectCount_ )
-      , pObjects( pObjects_ )
+                                        const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
+      : layout::DebugUtilsMessengerCallbackDataEXT( flags_, pMessageIdName_, messageIdNumber_, pMessage_, queueLabelCount_, pQueueLabels_, cmdBufLabelCount_, pCmdBufLabels_, objectCount_, pObjects_ )
     {}
 
     DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this) = rhs;
-    }
+      : layout::DebugUtilsMessengerCallbackDataEXT( rhs )
+    {}
 
     DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
     {
@@ -23823,7 +25934,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugUtilsMessengerCallbackDataEXT & setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ )
+    DebugUtilsMessengerCallbackDataEXT & setFlags( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
@@ -23853,7 +25964,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugUtilsMessengerCallbackDataEXT & setPQueueLabels( const DebugUtilsLabelEXT* pQueueLabels_ )
+    DebugUtilsMessengerCallbackDataEXT & setPQueueLabels( const vk::DebugUtilsLabelEXT* pQueueLabels_ )
     {
       pQueueLabels = pQueueLabels_;
       return *this;
@@ -23865,7 +25976,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( const DebugUtilsLabelEXT* pCmdBufLabels_ )
+    DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( const vk::DebugUtilsLabelEXT* pCmdBufLabels_ )
     {
       pCmdBufLabels = pCmdBufLabels_;
       return *this;
@@ -23877,7 +25988,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugUtilsMessengerCallbackDataEXT & setPObjects( const DebugUtilsObjectNameInfoEXT* pObjects_ )
+    DebugUtilsMessengerCallbackDataEXT & setPObjects( const vk::DebugUtilsObjectNameInfoEXT* pObjects_ )
     {
       pObjects = pObjects_;
       return *this;
@@ -23915,41 +26026,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugUtilsMessengerCallbackDataFlagsEXT flags;
-    const char* pMessageIdName;
-    int32_t messageIdNumber;
-    const char* pMessage;
-    uint32_t queueLabelCount;
-    const DebugUtilsLabelEXT* pQueueLabels;
-    uint32_t cmdBufLabelCount;
-    const DebugUtilsLabelEXT* pCmdBufLabels;
-    uint32_t objectCount;
-    const DebugUtilsObjectNameInfoEXT* pObjects;
+    using layout::DebugUtilsMessengerCallbackDataEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DebugUtilsMessengerCreateInfoEXT
+    {
+    protected:
+      DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(),
+                                        vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(),
+                                        vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(),
+                                        PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
+                                        void* pUserData_ = nullptr )
+        : flags( flags_ )
+        , messageSeverity( messageSeverity_ )
+        , messageType( messageType_ )
+        , pfnUserCallback( pfnUserCallback_ )
+        , pUserData( pUserData_ )
+      {}
+
+      DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this) = rhs;
+      }
+
+      DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::DebugUtilsMessengerCreateFlagsEXT flags;
+      vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity;
+      vk::DebugUtilsMessageTypeFlagsEXT messageType;
+      PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
+      void* pUserData;
+    };
+    static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DebugUtilsMessengerCreateInfoEXT
+  struct DebugUtilsMessengerCreateInfoEXT : public layout::DebugUtilsMessengerCreateInfoEXT
   {
-    DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = DebugUtilsMessengerCreateFlagsEXT(),
-                                      DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = DebugUtilsMessageSeverityFlagsEXT(),
-                                      DebugUtilsMessageTypeFlagsEXT messageType_ = DebugUtilsMessageTypeFlagsEXT(),
+    DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(),
+                                      vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(),
+                                      vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(),
                                       PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
                                       void* pUserData_ = nullptr )
-      : flags( flags_ )
-      , messageSeverity( messageSeverity_ )
-      , messageType( messageType_ )
-      , pfnUserCallback( pfnUserCallback_ )
-      , pUserData( pUserData_ )
+      : layout::DebugUtilsMessengerCreateInfoEXT( flags_, messageSeverity_, messageType_, pfnUserCallback_, pUserData_ )
     {}
 
     DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::DebugUtilsMessengerCreateInfoEXT( rhs )
+    {}
 
     DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
     {
@@ -23963,19 +26097,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugUtilsMessengerCreateInfoEXT & setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ )
+    DebugUtilsMessengerCreateInfoEXT & setFlags( vk::DebugUtilsMessengerCreateFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    DebugUtilsMessengerCreateInfoEXT & setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ )
+    DebugUtilsMessengerCreateInfoEXT & setMessageSeverity( vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ )
     {
       messageSeverity = messageSeverity_;
       return *this;
     }
 
-    DebugUtilsMessengerCreateInfoEXT & setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ )
+    DebugUtilsMessengerCreateInfoEXT & setMessageType( vk::DebugUtilsMessageTypeFlagsEXT messageType_ )
     {
       messageType = messageType_;
       return *this;
@@ -24020,36 +26154,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugUtilsMessengerCreateFlagsEXT flags;
-    DebugUtilsMessageSeverityFlagsEXT messageSeverity;
-    DebugUtilsMessageTypeFlagsEXT messageType;
-    PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
-    void* pUserData;
+    using layout::DebugUtilsMessengerCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DebugUtilsObjectTagInfoEXT
+    {
+    protected:
+      DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
+                                  uint64_t objectHandle_ = 0,
+                                  uint64_t tagName_ = 0,
+                                  size_t tagSize_ = 0,
+                                  const void* pTag_ = nullptr )
+        : objectType( objectType_ )
+        , objectHandle( objectHandle_ )
+        , tagName( tagName_ )
+        , tagSize( tagSize_ )
+        , pTag( pTag_ )
+      {}
+
+      DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this) = rhs;
+      }
+
+      DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct DebugUtilsObjectTagInfoEXT
+    public:
+      vk::StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
+      const void* pNext = nullptr;
+      vk::ObjectType objectType;
+      uint64_t objectHandle;
+      uint64_t tagName;
+      size_t tagSize;
+      const void* pTag;
+    };
+    static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DebugUtilsObjectTagInfoEXT : public layout::DebugUtilsObjectTagInfoEXT
   {
-    DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
+    DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
                                 uint64_t objectHandle_ = 0,
                                 uint64_t tagName_ = 0,
                                 size_t tagSize_ = 0,
                                 const void* pTag_ = nullptr )
-      : objectType( objectType_ )
-      , objectHandle( objectHandle_ )
-      , tagName( tagName_ )
-      , tagSize( tagSize_ )
-      , pTag( pTag_ )
+      : layout::DebugUtilsObjectTagInfoEXT( objectType_, objectHandle_, tagName_, tagSize_, pTag_ )
     {}
 
     DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this) = rhs;
-    }
+      : layout::DebugUtilsObjectTagInfoEXT( rhs )
+    {}
 
     DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
     {
@@ -24063,7 +26225,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DebugUtilsObjectTagInfoEXT & setObjectType( ObjectType objectType_ )
+    DebugUtilsObjectTagInfoEXT & setObjectType( vk::ObjectType objectType_ )
     {
       objectType = objectType_;
       return *this;
@@ -24120,28 +26282,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectType objectType;
-    uint64_t objectHandle;
-    uint64_t tagName;
-    size_t tagSize;
-    const void* pTag;
+    using layout::DebugUtilsObjectTagInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DedicatedAllocationBufferCreateInfoNV
+    {
+    protected:
+      DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 )
+        : dedicatedAllocation( dedicatedAllocation_ )
+      {}
 
-  struct DedicatedAllocationBufferCreateInfoNV
+      DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this) = rhs;
+      }
+
+      DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::Bool32 dedicatedAllocation;
+    };
+    static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DedicatedAllocationBufferCreateInfoNV : public layout::DedicatedAllocationBufferCreateInfoNV
   {
-    DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
-      : dedicatedAllocation( dedicatedAllocation_ )
+    DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 )
+      : layout::DedicatedAllocationBufferCreateInfoNV( dedicatedAllocation_ )
     {}
 
     DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this) = rhs;
-    }
+      : layout::DedicatedAllocationBufferCreateInfoNV( rhs )
+    {}
 
     DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
     {
@@ -24155,7 +26337,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ )
+    DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation( vk::Bool32 dedicatedAllocation_ )
     {
       dedicatedAllocation = dedicatedAllocation_;
       return *this;
@@ -24184,24 +26366,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 dedicatedAllocation;
+    using layout::DedicatedAllocationBufferCreateInfoNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DedicatedAllocationImageCreateInfoNV
+    {
+    protected:
+      DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 )
+        : dedicatedAllocation( dedicatedAllocation_ )
+      {}
 
-  struct DedicatedAllocationImageCreateInfoNV
+      DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this) = rhs;
+      }
+
+      DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::Bool32 dedicatedAllocation;
+    };
+    static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DedicatedAllocationImageCreateInfoNV : public layout::DedicatedAllocationImageCreateInfoNV
   {
-    DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
-      : dedicatedAllocation( dedicatedAllocation_ )
+    DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 )
+      : layout::DedicatedAllocationImageCreateInfoNV( dedicatedAllocation_ )
     {}
 
     DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this) = rhs;
-    }
+      : layout::DedicatedAllocationImageCreateInfoNV( rhs )
+    {}
 
     DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
     {
@@ -24215,7 +26421,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ )
+    DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation( vk::Bool32 dedicatedAllocation_ )
     {
       dedicatedAllocation = dedicatedAllocation_;
       return *this;
@@ -24244,26 +26450,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 dedicatedAllocation;
+    using layout::DedicatedAllocationImageCreateInfoNV::sType;
   };
   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!" );
 
-  struct DedicatedAllocationMemoryAllocateInfoNV
+  namespace layout
   {
-    DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(),
-                                             Buffer buffer_ = Buffer() )
-      : image( image_ )
-      , buffer( buffer_ )
+    struct DedicatedAllocationMemoryAllocateInfoNV
+    {
+    protected:
+      DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(),
+                                               vk::Buffer buffer_ = vk::Buffer() )
+        : image( image_ )
+        , buffer( buffer_ )
+      {}
+
+      DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this) = rhs;
+      }
+
+      DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
+      const void* pNext = nullptr;
+      vk::Image image;
+      vk::Buffer buffer;
+    };
+    static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DedicatedAllocationMemoryAllocateInfoNV : public layout::DedicatedAllocationMemoryAllocateInfoNV
+  {
+    DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(),
+                                             vk::Buffer buffer_ = vk::Buffer() )
+      : layout::DedicatedAllocationMemoryAllocateInfoNV( image_, buffer_ )
     {}
 
     DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this) = rhs;
-    }
+      : layout::DedicatedAllocationMemoryAllocateInfoNV( rhs )
+    {}
 
     DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
     {
@@ -24277,13 +26509,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DedicatedAllocationMemoryAllocateInfoNV & setImage( Image image_ )
+    DedicatedAllocationMemoryAllocateInfoNV & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
     }
 
-    DedicatedAllocationMemoryAllocateInfoNV & setBuffer( Buffer buffer_ )
+    DedicatedAllocationMemoryAllocateInfoNV & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
@@ -24313,23 +26545,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    Buffer buffer;
+    using layout::DedicatedAllocationMemoryAllocateInfoNV::sType;
   };
   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!" );
 
   struct DescriptorBufferInfo
   {
-    DescriptorBufferInfo( Buffer buffer_ = Buffer(),
-                          DeviceSize offset_ = 0,
-                          DeviceSize range_ = 0 )
-      : buffer( buffer_ )
-      , offset( offset_ )
-      , range( range_ )
+    DescriptorBufferInfo( vk::Buffer buffer_ = vk::Buffer(),
+                          vk::DeviceSize offset_ = 0,
+                          vk::DeviceSize range_ = 0 )
+        : buffer( buffer_ )
+        , offset( offset_ )
+        , range( range_ )
     {}
 
     DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs )
@@ -24343,19 +26571,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorBufferInfo & setBuffer( Buffer buffer_ )
+    DescriptorBufferInfo & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
     }
 
-    DescriptorBufferInfo & setOffset( DeviceSize offset_ )
+    DescriptorBufferInfo & setOffset( vk::DeviceSize offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    DescriptorBufferInfo & setRange( DeviceSize range_ )
+    DescriptorBufferInfo & setRange( vk::DeviceSize range_ )
     {
       range = range_;
       return *this;
@@ -24383,20 +26611,22 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Buffer buffer;
-    DeviceSize offset;
-    DeviceSize range;
+  public:
+    vk::Buffer buffer;
+    vk::DeviceSize offset;
+    vk::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
   {
-    DescriptorImageInfo( Sampler sampler_ = Sampler(),
-                         ImageView imageView_ = ImageView(),
-                         ImageLayout imageLayout_ = ImageLayout::eUndefined )
-      : sampler( sampler_ )
-      , imageView( imageView_ )
-      , imageLayout( imageLayout_ )
+    DescriptorImageInfo( vk::Sampler sampler_ = vk::Sampler(),
+                         vk::ImageView imageView_ = vk::ImageView(),
+                         vk::ImageLayout imageLayout_ = vk::ImageLayout::eUndefined )
+        : sampler( sampler_ )
+        , imageView( imageView_ )
+        , imageLayout( imageLayout_ )
     {}
 
     DescriptorImageInfo( VkDescriptorImageInfo const & rhs )
@@ -24410,19 +26640,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorImageInfo & setSampler( Sampler sampler_ )
+    DescriptorImageInfo & setSampler( vk::Sampler sampler_ )
     {
       sampler = sampler_;
       return *this;
     }
 
-    DescriptorImageInfo & setImageView( ImageView imageView_ )
+    DescriptorImageInfo & setImageView( vk::ImageView imageView_ )
     {
       imageView = imageView_;
       return *this;
     }
 
-    DescriptorImageInfo & setImageLayout( ImageLayout imageLayout_ )
+    DescriptorImageInfo & setImageLayout( vk::ImageLayout imageLayout_ )
     {
       imageLayout = imageLayout_;
       return *this;
@@ -24450,18 +26680,20 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Sampler sampler;
-    ImageView imageView;
-    ImageLayout imageLayout;
+  public:
+    vk::Sampler sampler;
+    vk::ImageView imageView;
+    vk::ImageLayout imageLayout;
   };
   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
   {
-    DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler,
+    DescriptorPoolSize( vk::DescriptorType type_ = vk::DescriptorType::eSampler,
                         uint32_t descriptorCount_ = 0 )
-      : type( type_ )
-      , descriptorCount( descriptorCount_ )
+        : type( type_ )
+        , descriptorCount( descriptorCount_ )
     {}
 
     DescriptorPoolSize( VkDescriptorPoolSize const & rhs )
@@ -24475,7 +26707,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorPoolSize & setType( DescriptorType type_ )
+    DescriptorPoolSize & setType( vk::DescriptorType type_ )
     {
       type = type_;
       return *this;
@@ -24508,27 +26740,62 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DescriptorType type;
+  public:
+    vk::DescriptorType type;
     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!" );
+
+  namespace layout
+  {
+    struct DescriptorPoolCreateInfo
+    {
+    protected:
+      DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(),
+                                uint32_t maxSets_ = 0,
+                                uint32_t poolSizeCount_ = 0,
+                                const vk::DescriptorPoolSize* pPoolSizes_ = nullptr )
+        : flags( flags_ )
+        , maxSets( maxSets_ )
+        , poolSizeCount( poolSizeCount_ )
+        , pPoolSizes( pPoolSizes_ )
+      {}
+
+      DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this) = rhs;
+      }
+
+      DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDescriptorPoolCreateInfo;
+      const void* pNext = nullptr;
+      vk::DescriptorPoolCreateFlags flags;
+      uint32_t maxSets;
+      uint32_t poolSizeCount;
+      const vk::DescriptorPoolSize* pPoolSizes;
+    };
+    static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DescriptorPoolCreateInfo
+  struct DescriptorPoolCreateInfo : public layout::DescriptorPoolCreateInfo
   {
-    DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(),
+    DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(),
                               uint32_t maxSets_ = 0,
                               uint32_t poolSizeCount_ = 0,
-                              const DescriptorPoolSize* pPoolSizes_ = nullptr )
-      : flags( flags_ )
-      , maxSets( maxSets_ )
-      , poolSizeCount( poolSizeCount_ )
-      , pPoolSizes( pPoolSizes_ )
+                              const vk::DescriptorPoolSize* pPoolSizes_ = nullptr )
+      : layout::DescriptorPoolCreateInfo( flags_, maxSets_, poolSizeCount_, pPoolSizes_ )
     {}
 
     DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this) = rhs;
-    }
+      : layout::DescriptorPoolCreateInfo( rhs )
+    {}
 
     DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
     {
@@ -24542,7 +26809,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorPoolCreateInfo & setFlags( DescriptorPoolCreateFlags flags_ )
+    DescriptorPoolCreateInfo & setFlags( vk::DescriptorPoolCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -24560,7 +26827,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorPoolCreateInfo & setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
+    DescriptorPoolCreateInfo & setPPoolSizes( const vk::DescriptorPoolSize* pPoolSizes_ )
     {
       pPoolSizes = pPoolSizes_;
       return *this;
@@ -24592,27 +26859,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorPoolCreateFlags flags;
-    uint32_t maxSets;
-    uint32_t poolSizeCount;
-    const DescriptorPoolSize* pPoolSizes;
+    using layout::DescriptorPoolCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DescriptorPoolInlineUniformBlockCreateInfoEXT
+    {
+    protected:
+      DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
+        : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
+      {}
+
+      DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this) = rhs;
+      }
+
+      DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct DescriptorPoolInlineUniformBlockCreateInfoEXT
+    public:
+      vk::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
+      const void* pNext = nullptr;
+      uint32_t maxInlineUniformBlockBindings;
+    };
+    static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DescriptorPoolInlineUniformBlockCreateInfoEXT : public layout::DescriptorPoolInlineUniformBlockCreateInfoEXT
   {
     DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
-      : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
+      : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( maxInlineUniformBlockBindings_ )
     {}
 
     DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( rhs )
+    {}
 
     DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
     {
@@ -24655,28 +26943,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t maxInlineUniformBlockBindings;
+    using layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DescriptorSetAllocateInfo
+    {
+    protected:
+      DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(),
+                                 uint32_t descriptorSetCount_ = 0,
+                                 const vk::DescriptorSetLayout* pSetLayouts_ = nullptr )
+        : descriptorPool( descriptorPool_ )
+        , descriptorSetCount( descriptorSetCount_ )
+        , pSetLayouts( pSetLayouts_ )
+      {}
+
+      DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this) = rhs;
+      }
+
+      DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDescriptorSetAllocateInfo;
+      const void* pNext = nullptr;
+      vk::DescriptorPool descriptorPool;
+      uint32_t descriptorSetCount;
+      const vk::DescriptorSetLayout* pSetLayouts;
+    };
+    static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DescriptorSetAllocateInfo
+  struct DescriptorSetAllocateInfo : public layout::DescriptorSetAllocateInfo
   {
-    DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(),
+    DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(),
                                uint32_t descriptorSetCount_ = 0,
-                               const DescriptorSetLayout* pSetLayouts_ = nullptr )
-      : descriptorPool( descriptorPool_ )
-      , descriptorSetCount( descriptorSetCount_ )
-      , pSetLayouts( pSetLayouts_ )
+                               const vk::DescriptorSetLayout* pSetLayouts_ = nullptr )
+      : layout::DescriptorSetAllocateInfo( descriptorPool_, descriptorSetCount_, pSetLayouts_ )
     {}
 
     DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs )
-    {
-      *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this) = rhs;
-    }
+      : layout::DescriptorSetAllocateInfo( rhs )
+    {}
 
     DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs )
     {
@@ -24690,7 +27006,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorSetAllocateInfo & setDescriptorPool( DescriptorPool descriptorPool_ )
+    DescriptorSetAllocateInfo & setDescriptorPool( vk::DescriptorPool descriptorPool_ )
     {
       descriptorPool = descriptorPool_;
       return *this;
@@ -24702,7 +27018,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorSetAllocateInfo & setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+    DescriptorSetAllocateInfo & setPSetLayouts( const vk::DescriptorSetLayout* pSetLayouts_ )
     {
       pSetLayouts = pSetLayouts_;
       return *this;
@@ -24733,28 +27049,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorSetAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorPool descriptorPool;
-    uint32_t descriptorSetCount;
-    const DescriptorSetLayout* pSetLayouts;
+    using layout::DescriptorSetAllocateInfo::sType;
   };
   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!" );
 
   struct DescriptorSetLayoutBinding
   {
     DescriptorSetLayoutBinding( uint32_t binding_ = 0,
-                                DescriptorType descriptorType_ = DescriptorType::eSampler,
+                                vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
                                 uint32_t descriptorCount_ = 0,
-                                ShaderStageFlags stageFlags_ = ShaderStageFlags(),
-                                const Sampler* pImmutableSamplers_ = nullptr )
-      : binding( binding_ )
-      , descriptorType( descriptorType_ )
-      , descriptorCount( descriptorCount_ )
-      , stageFlags( stageFlags_ )
-      , pImmutableSamplers( pImmutableSamplers_ )
+                                vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags(),
+                                const vk::Sampler* pImmutableSamplers_ = nullptr )
+        : binding( binding_ )
+        , descriptorType( descriptorType_ )
+        , descriptorCount( descriptorCount_ )
+        , stageFlags( stageFlags_ )
+        , pImmutableSamplers( pImmutableSamplers_ )
     {}
 
     DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
@@ -24774,7 +27085,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorSetLayoutBinding & setDescriptorType( DescriptorType descriptorType_ )
+    DescriptorSetLayoutBinding & setDescriptorType( vk::DescriptorType descriptorType_ )
     {
       descriptorType = descriptorType_;
       return *this;
@@ -24786,13 +27097,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorSetLayoutBinding & setStageFlags( ShaderStageFlags stageFlags_ )
+    DescriptorSetLayoutBinding & setStageFlags( vk::ShaderStageFlags stageFlags_ )
     {
       stageFlags = stageFlags_;
       return *this;
     }
 
-    DescriptorSetLayoutBinding & setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
+    DescriptorSetLayoutBinding & setPImmutableSamplers( const vk::Sampler* pImmutableSamplers_ )
     {
       pImmutableSamplers = pImmutableSamplers_;
       return *this;
@@ -24822,26 +27133,57 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t binding;
-    DescriptorType descriptorType;
+    vk::DescriptorType descriptorType;
     uint32_t descriptorCount;
-    ShaderStageFlags stageFlags;
-    const Sampler* pImmutableSamplers;
+    vk::ShaderStageFlags stageFlags;
+    const vk::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!" );
+
+  namespace layout
+  {
+    struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
+    {
+    protected:
+      DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
+                                                    const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
+        : bindingCount( bindingCount_ )
+        , pBindingFlags( pBindingFlags_ )
+      {}
+
+      DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this) = rhs;
+      }
+
+      DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
+    public:
+      vk::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
+      const void* pNext = nullptr;
+      uint32_t bindingCount;
+      const vk::DescriptorBindingFlagsEXT* pBindingFlags;
+    };
+    static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DescriptorSetLayoutBindingFlagsCreateInfoEXT : public layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT
   {
     DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
-                                                  const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
-      : bindingCount( bindingCount_ )
-      , pBindingFlags( pBindingFlags_ )
+                                                  const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
+      : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( bindingCount_, pBindingFlags_ )
     {}
 
     DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( rhs )
+    {}
 
     DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
     {
@@ -24861,7 +27203,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPBindingFlags( const DescriptorBindingFlagsEXT* pBindingFlags_ )
+    DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPBindingFlags( const vk::DescriptorBindingFlagsEXT* pBindingFlags_ )
     {
       pBindingFlags = pBindingFlags_;
       return *this;
@@ -24891,29 +27233,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t bindingCount;
-    const DescriptorBindingFlagsEXT* pBindingFlags;
+    using layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::sType;
   };
   static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<DescriptorSetLayoutBindingFlagsCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct DescriptorSetLayoutCreateInfo
+    {
+    protected:
+      DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(),
+                                     uint32_t bindingCount_ = 0,
+                                     const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr )
+        : flags( flags_ )
+        , bindingCount( bindingCount_ )
+        , pBindings( pBindings_ )
+      {}
 
-  struct DescriptorSetLayoutCreateInfo
+      DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this) = rhs;
+      }
+
+      DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
+      const void* pNext = nullptr;
+      vk::DescriptorSetLayoutCreateFlags flags;
+      uint32_t bindingCount;
+      const vk::DescriptorSetLayoutBinding* pBindings;
+    };
+    static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DescriptorSetLayoutCreateInfo : public layout::DescriptorSetLayoutCreateInfo
   {
-    DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(),
+    DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(),
                                    uint32_t bindingCount_ = 0,
-                                   const DescriptorSetLayoutBinding* pBindings_ = nullptr )
-      : flags( flags_ )
-      , bindingCount( bindingCount_ )
-      , pBindings( pBindings_ )
+                                   const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr )
+      : layout::DescriptorSetLayoutCreateInfo( flags_, bindingCount_, pBindings_ )
     {}
 
     DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this) = rhs;
-    }
+      : layout::DescriptorSetLayoutCreateInfo( rhs )
+    {}
 
     DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
     {
@@ -24927,7 +27296,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorSetLayoutCreateInfo & setFlags( DescriptorSetLayoutCreateFlags flags_ )
+    DescriptorSetLayoutCreateInfo & setFlags( vk::DescriptorSetLayoutCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -24939,7 +27308,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorSetLayoutCreateInfo & setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
+    DescriptorSetLayoutCreateInfo & setPBindings( const vk::DescriptorSetLayoutBinding* pBindings_ )
     {
       pBindings = pBindings_;
       return *this;
@@ -24970,17 +27339,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorSetLayoutCreateFlags flags;
-    uint32_t bindingCount;
-    const DescriptorSetLayoutBinding* pBindings;
+    using layout::DescriptorSetLayoutCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DescriptorSetLayoutSupport
+    {
+    protected:
+      DescriptorSetLayoutSupport( vk::Bool32 supported_ = 0 )
+        : supported( supported_ )
+      {}
 
-  struct DescriptorSetLayoutSupport
+      DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this) = rhs;
+      }
+
+      DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDescriptorSetLayoutSupport;
+      void* pNext = nullptr;
+      vk::Bool32 supported;
+    };
+    static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DescriptorSetLayoutSupport : public layout::DescriptorSetLayoutSupport
   {
     operator VkDescriptorSetLayoutSupport const&() const
     {
@@ -25005,26 +27397,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorSetLayoutSupport;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 supported;
+    using layout::DescriptorSetLayoutSupport::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
+    {
+    protected:
+      DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
+                                                           const uint32_t* pDescriptorCounts_ = nullptr )
+        : descriptorSetCount( descriptorSetCount_ )
+        , pDescriptorCounts( pDescriptorCounts_ )
+      {}
 
-  struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
+      DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this) = rhs;
+      }
+
+      DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT;
+      const void* pNext = nullptr;
+      uint32_t descriptorSetCount;
+      const uint32_t* pDescriptorCounts;
+    };
+    static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DescriptorSetVariableDescriptorCountAllocateInfoEXT : public layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT
   {
     DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
                                                          const uint32_t* pDescriptorCounts_ = nullptr )
-      : descriptorSetCount( descriptorSetCount_ )
-      , pDescriptorCounts( pDescriptorCounts_ )
+      : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( descriptorSetCount_, pDescriptorCounts_ )
     {}
 
     DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this) = rhs;
-    }
+      : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( rhs )
+    {}
 
     DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
     {
@@ -25074,16 +27492,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t descriptorSetCount;
-    const uint32_t* pDescriptorCounts;
+    using layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::sType;
   };
   static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountAllocateInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
+    {
+    protected:
+      DescriptorSetVariableDescriptorCountLayoutSupportEXT( uint32_t maxVariableDescriptorCount_ = 0 )
+        : maxVariableDescriptorCount( maxVariableDescriptorCount_ )
+      {}
+
+      DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this) = rhs;
+      }
+
+      DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT;
+      void* pNext = nullptr;
+      uint32_t maxVariableDescriptorCount;
+    };
+    static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
+  struct DescriptorSetVariableDescriptorCountLayoutSupportEXT : public layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT
   {
     operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const&() const
     {
@@ -25108,28 +27550,25 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxVariableDescriptorCount;
+    using layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::sType;
   };
   static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountLayoutSupportEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct DescriptorUpdateTemplateEntry
   {
     DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = 0,
                                    uint32_t dstArrayElement_ = 0,
                                    uint32_t descriptorCount_ = 0,
-                                   DescriptorType descriptorType_ = DescriptorType::eSampler,
+                                   vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
                                    size_t offset_ = 0,
                                    size_t stride_ = 0 )
-      : dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
-      , descriptorType( descriptorType_ )
-      , offset( offset_ )
-      , stride( stride_ )
+        : dstBinding( dstBinding_ )
+        , dstArrayElement( dstArrayElement_ )
+        , descriptorCount( descriptorCount_ )
+        , descriptorType( descriptorType_ )
+        , offset( offset_ )
+        , stride( stride_ )
     {}
 
     DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs )
@@ -25161,7 +27600,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorUpdateTemplateEntry & setDescriptorType( DescriptorType descriptorType_ )
+    DescriptorUpdateTemplateEntry & setDescriptorType( vk::DescriptorType descriptorType_ )
     {
       descriptorType = descriptorType_;
       return *this;
@@ -25204,39 +27643,82 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t dstBinding;
     uint32_t dstArrayElement;
     uint32_t descriptorCount;
-    DescriptorType descriptorType;
+    vk::DescriptorType descriptorType;
     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!" );
+
+  namespace layout
+  {
+    struct DescriptorUpdateTemplateCreateInfo
+    {
+    protected:
+      DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(),
+                                          uint32_t descriptorUpdateEntryCount_ = 0,
+                                          const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
+                                          vk::DescriptorUpdateTemplateType templateType_ = vk::DescriptorUpdateTemplateType::eDescriptorSet,
+                                          vk::DescriptorSetLayout descriptorSetLayout_ = vk::DescriptorSetLayout(),
+                                          vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+                                          vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+                                          uint32_t set_ = 0 )
+        : flags( flags_ )
+        , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
+        , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
+        , templateType( templateType_ )
+        , descriptorSetLayout( descriptorSetLayout_ )
+        , pipelineBindPoint( pipelineBindPoint_ )
+        , pipelineLayout( pipelineLayout_ )
+        , set( set_ )
+      {}
+
+      DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this) = rhs;
+      }
+
+      DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
+      const void* pNext = nullptr;
+      vk::DescriptorUpdateTemplateCreateFlags flags;
+      uint32_t descriptorUpdateEntryCount;
+      const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
+      vk::DescriptorUpdateTemplateType templateType;
+      vk::DescriptorSetLayout descriptorSetLayout;
+      vk::PipelineBindPoint pipelineBindPoint;
+      vk::PipelineLayout pipelineLayout;
+      uint32_t set;
+    };
+    static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DescriptorUpdateTemplateCreateInfo
+  struct DescriptorUpdateTemplateCreateInfo : public layout::DescriptorUpdateTemplateCreateInfo
   {
-    DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(),
+    DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(),
                                         uint32_t descriptorUpdateEntryCount_ = 0,
-                                        const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
-                                        DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
-                                        DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
-                                        PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
-                                        PipelineLayout pipelineLayout_ = PipelineLayout(),
+                                        const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
+                                        vk::DescriptorUpdateTemplateType templateType_ = vk::DescriptorUpdateTemplateType::eDescriptorSet,
+                                        vk::DescriptorSetLayout descriptorSetLayout_ = vk::DescriptorSetLayout(),
+                                        vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+                                        vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
                                         uint32_t set_ = 0 )
-      : flags( flags_ )
-      , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
-      , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
-      , templateType( templateType_ )
-      , descriptorSetLayout( descriptorSetLayout_ )
-      , pipelineBindPoint( pipelineBindPoint_ )
-      , pipelineLayout( pipelineLayout_ )
-      , set( set_ )
+      : layout::DescriptorUpdateTemplateCreateInfo( flags_, descriptorUpdateEntryCount_, pDescriptorUpdateEntries_, templateType_, descriptorSetLayout_, pipelineBindPoint_, pipelineLayout_, set_ )
     {}
 
     DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this) = rhs;
-    }
+      : layout::DescriptorUpdateTemplateCreateInfo( rhs )
+    {}
 
     DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
     {
@@ -25250,7 +27732,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo & setFlags( DescriptorUpdateTemplateCreateFlags flags_ )
+    DescriptorUpdateTemplateCreateInfo & setFlags( vk::DescriptorUpdateTemplateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -25262,31 +27744,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo & setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
+    DescriptorUpdateTemplateCreateInfo & setPDescriptorUpdateEntries( const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
     {
       pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo & setTemplateType( DescriptorUpdateTemplateType templateType_ )
+    DescriptorUpdateTemplateCreateInfo & setTemplateType( vk::DescriptorUpdateTemplateType templateType_ )
     {
       templateType = templateType_;
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
+    DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout_ )
     {
       descriptorSetLayout = descriptorSetLayout_;
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( vk::PipelineBindPoint pipelineBindPoint_ )
     {
       pipelineBindPoint = pipelineBindPoint_;
       return *this;
     }
 
-    DescriptorUpdateTemplateCreateInfo & setPipelineLayout( PipelineLayout pipelineLayout_ )
+    DescriptorUpdateTemplateCreateInfo & setPipelineLayout( vk::PipelineLayout pipelineLayout_ )
     {
       pipelineLayout = pipelineLayout_;
       return *this;
@@ -25328,37 +27810,60 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorUpdateTemplateCreateFlags flags;
-    uint32_t descriptorUpdateEntryCount;
-    const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
-    DescriptorUpdateTemplateType templateType;
-    DescriptorSetLayout descriptorSetLayout;
-    PipelineBindPoint pipelineBindPoint;
-    PipelineLayout pipelineLayout;
-    uint32_t set;
+    using layout::DescriptorUpdateTemplateCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceQueueCreateInfo
+    {
+    protected:
+      DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
+                             uint32_t queueFamilyIndex_ = 0,
+                             uint32_t queueCount_ = 0,
+                             const float* pQueuePriorities_ = nullptr )
+        : flags( flags_ )
+        , queueFamilyIndex( queueFamilyIndex_ )
+        , queueCount( queueCount_ )
+        , pQueuePriorities( pQueuePriorities_ )
+      {}
+
+      DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceQueueCreateInfo*>(this) = rhs;
+      }
 
-  struct DeviceQueueCreateInfo
+      DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceQueueCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceQueueCreateInfo;
+      const void* pNext = nullptr;
+      vk::DeviceQueueCreateFlags flags;
+      uint32_t queueFamilyIndex;
+      uint32_t queueCount;
+      const float* pQueuePriorities;
+    };
+    static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceQueueCreateInfo : public layout::DeviceQueueCreateInfo
   {
-    DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
+    DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
                            uint32_t queueFamilyIndex_ = 0,
                            uint32_t queueCount_ = 0,
                            const float* pQueuePriorities_ = nullptr )
-      : flags( flags_ )
-      , queueFamilyIndex( queueFamilyIndex_ )
-      , queueCount( queueCount_ )
-      , pQueuePriorities( pQueuePriorities_ )
+      : layout::DeviceQueueCreateInfo( flags_, queueFamilyIndex_, queueCount_, pQueuePriorities_ )
     {}
 
     DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkDeviceQueueCreateInfo*>(this) = rhs;
-    }
+      : layout::DeviceQueueCreateInfo( rhs )
+    {}
 
     DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
     {
@@ -25372,7 +27877,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceQueueCreateInfo & setFlags( DeviceQueueCreateFlags flags_ )
+    DeviceQueueCreateInfo & setFlags( vk::DeviceQueueCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -25422,129 +27927,123 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceQueueCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceQueueCreateFlags flags;
-    uint32_t queueFamilyIndex;
-    uint32_t queueCount;
-    const float* pQueuePriorities;
+    using layout::DeviceQueueCreateInfo::sType;
   };
   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!" );
 
   struct PhysicalDeviceFeatures
   {
-    PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0,
-                            Bool32 fullDrawIndexUint32_ = 0,
-                            Bool32 imageCubeArray_ = 0,
-                            Bool32 independentBlend_ = 0,
-                            Bool32 geometryShader_ = 0,
-                            Bool32 tessellationShader_ = 0,
-                            Bool32 sampleRateShading_ = 0,
-                            Bool32 dualSrcBlend_ = 0,
-                            Bool32 logicOp_ = 0,
-                            Bool32 multiDrawIndirect_ = 0,
-                            Bool32 drawIndirectFirstInstance_ = 0,
-                            Bool32 depthClamp_ = 0,
-                            Bool32 depthBiasClamp_ = 0,
-                            Bool32 fillModeNonSolid_ = 0,
-                            Bool32 depthBounds_ = 0,
-                            Bool32 wideLines_ = 0,
-                            Bool32 largePoints_ = 0,
-                            Bool32 alphaToOne_ = 0,
-                            Bool32 multiViewport_ = 0,
-                            Bool32 samplerAnisotropy_ = 0,
-                            Bool32 textureCompressionETC2_ = 0,
-                            Bool32 textureCompressionASTC_LDR_ = 0,
-                            Bool32 textureCompressionBC_ = 0,
-                            Bool32 occlusionQueryPrecise_ = 0,
-                            Bool32 pipelineStatisticsQuery_ = 0,
-                            Bool32 vertexPipelineStoresAndAtomics_ = 0,
-                            Bool32 fragmentStoresAndAtomics_ = 0,
-                            Bool32 shaderTessellationAndGeometryPointSize_ = 0,
-                            Bool32 shaderImageGatherExtended_ = 0,
-                            Bool32 shaderStorageImageExtendedFormats_ = 0,
-                            Bool32 shaderStorageImageMultisample_ = 0,
-                            Bool32 shaderStorageImageReadWithoutFormat_ = 0,
-                            Bool32 shaderStorageImageWriteWithoutFormat_ = 0,
-                            Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0,
-                            Bool32 shaderSampledImageArrayDynamicIndexing_ = 0,
-                            Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0,
-                            Bool32 shaderStorageImageArrayDynamicIndexing_ = 0,
-                            Bool32 shaderClipDistance_ = 0,
-                            Bool32 shaderCullDistance_ = 0,
-                            Bool32 shaderFloat64_ = 0,
-                            Bool32 shaderInt64_ = 0,
-                            Bool32 shaderInt16_ = 0,
-                            Bool32 shaderResourceResidency_ = 0,
-                            Bool32 shaderResourceMinLod_ = 0,
-                            Bool32 sparseBinding_ = 0,
-                            Bool32 sparseResidencyBuffer_ = 0,
-                            Bool32 sparseResidencyImage2D_ = 0,
-                            Bool32 sparseResidencyImage3D_ = 0,
-                            Bool32 sparseResidency2Samples_ = 0,
-                            Bool32 sparseResidency4Samples_ = 0,
-                            Bool32 sparseResidency8Samples_ = 0,
-                            Bool32 sparseResidency16Samples_ = 0,
-                            Bool32 sparseResidencyAliased_ = 0,
-                            Bool32 variableMultisampleRate_ = 0,
-                            Bool32 inheritedQueries_ = 0 )
-      : robustBufferAccess( robustBufferAccess_ )
-      , fullDrawIndexUint32( fullDrawIndexUint32_ )
-      , imageCubeArray( imageCubeArray_ )
-      , independentBlend( independentBlend_ )
-      , geometryShader( geometryShader_ )
-      , tessellationShader( tessellationShader_ )
-      , sampleRateShading( sampleRateShading_ )
-      , dualSrcBlend( dualSrcBlend_ )
-      , logicOp( logicOp_ )
-      , multiDrawIndirect( multiDrawIndirect_ )
-      , drawIndirectFirstInstance( drawIndirectFirstInstance_ )
-      , depthClamp( depthClamp_ )
-      , depthBiasClamp( depthBiasClamp_ )
-      , fillModeNonSolid( fillModeNonSolid_ )
-      , depthBounds( depthBounds_ )
-      , wideLines( wideLines_ )
-      , largePoints( largePoints_ )
-      , alphaToOne( alphaToOne_ )
-      , multiViewport( multiViewport_ )
-      , samplerAnisotropy( samplerAnisotropy_ )
-      , textureCompressionETC2( textureCompressionETC2_ )
-      , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ )
-      , textureCompressionBC( textureCompressionBC_ )
-      , occlusionQueryPrecise( occlusionQueryPrecise_ )
-      , pipelineStatisticsQuery( pipelineStatisticsQuery_ )
-      , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ )
-      , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ )
-      , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ )
-      , shaderImageGatherExtended( shaderImageGatherExtended_ )
-      , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ )
-      , shaderStorageImageMultisample( shaderStorageImageMultisample_ )
-      , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ )
-      , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ )
-      , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ )
-      , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ )
-      , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ )
-      , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ )
-      , shaderClipDistance( shaderClipDistance_ )
-      , shaderCullDistance( shaderCullDistance_ )
-      , shaderFloat64( shaderFloat64_ )
-      , shaderInt64( shaderInt64_ )
-      , shaderInt16( shaderInt16_ )
-      , shaderResourceResidency( shaderResourceResidency_ )
-      , shaderResourceMinLod( shaderResourceMinLod_ )
-      , sparseBinding( sparseBinding_ )
-      , sparseResidencyBuffer( sparseResidencyBuffer_ )
-      , sparseResidencyImage2D( sparseResidencyImage2D_ )
-      , sparseResidencyImage3D( sparseResidencyImage3D_ )
-      , sparseResidency2Samples( sparseResidency2Samples_ )
-      , sparseResidency4Samples( sparseResidency4Samples_ )
-      , sparseResidency8Samples( sparseResidency8Samples_ )
-      , sparseResidency16Samples( sparseResidency16Samples_ )
-      , sparseResidencyAliased( sparseResidencyAliased_ )
-      , variableMultisampleRate( variableMultisampleRate_ )
-      , inheritedQueries( inheritedQueries_ )
+    PhysicalDeviceFeatures( vk::Bool32 robustBufferAccess_ = 0,
+                            vk::Bool32 fullDrawIndexUint32_ = 0,
+                            vk::Bool32 imageCubeArray_ = 0,
+                            vk::Bool32 independentBlend_ = 0,
+                            vk::Bool32 geometryShader_ = 0,
+                            vk::Bool32 tessellationShader_ = 0,
+                            vk::Bool32 sampleRateShading_ = 0,
+                            vk::Bool32 dualSrcBlend_ = 0,
+                            vk::Bool32 logicOp_ = 0,
+                            vk::Bool32 multiDrawIndirect_ = 0,
+                            vk::Bool32 drawIndirectFirstInstance_ = 0,
+                            vk::Bool32 depthClamp_ = 0,
+                            vk::Bool32 depthBiasClamp_ = 0,
+                            vk::Bool32 fillModeNonSolid_ = 0,
+                            vk::Bool32 depthBounds_ = 0,
+                            vk::Bool32 wideLines_ = 0,
+                            vk::Bool32 largePoints_ = 0,
+                            vk::Bool32 alphaToOne_ = 0,
+                            vk::Bool32 multiViewport_ = 0,
+                            vk::Bool32 samplerAnisotropy_ = 0,
+                            vk::Bool32 textureCompressionETC2_ = 0,
+                            vk::Bool32 textureCompressionASTC_LDR_ = 0,
+                            vk::Bool32 textureCompressionBC_ = 0,
+                            vk::Bool32 occlusionQueryPrecise_ = 0,
+                            vk::Bool32 pipelineStatisticsQuery_ = 0,
+                            vk::Bool32 vertexPipelineStoresAndAtomics_ = 0,
+                            vk::Bool32 fragmentStoresAndAtomics_ = 0,
+                            vk::Bool32 shaderTessellationAndGeometryPointSize_ = 0,
+                            vk::Bool32 shaderImageGatherExtended_ = 0,
+                            vk::Bool32 shaderStorageImageExtendedFormats_ = 0,
+                            vk::Bool32 shaderStorageImageMultisample_ = 0,
+                            vk::Bool32 shaderStorageImageReadWithoutFormat_ = 0,
+                            vk::Bool32 shaderStorageImageWriteWithoutFormat_ = 0,
+                            vk::Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0,
+                            vk::Bool32 shaderSampledImageArrayDynamicIndexing_ = 0,
+                            vk::Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0,
+                            vk::Bool32 shaderStorageImageArrayDynamicIndexing_ = 0,
+                            vk::Bool32 shaderClipDistance_ = 0,
+                            vk::Bool32 shaderCullDistance_ = 0,
+                            vk::Bool32 shaderFloat64_ = 0,
+                            vk::Bool32 shaderInt64_ = 0,
+                            vk::Bool32 shaderInt16_ = 0,
+                            vk::Bool32 shaderResourceResidency_ = 0,
+                            vk::Bool32 shaderResourceMinLod_ = 0,
+                            vk::Bool32 sparseBinding_ = 0,
+                            vk::Bool32 sparseResidencyBuffer_ = 0,
+                            vk::Bool32 sparseResidencyImage2D_ = 0,
+                            vk::Bool32 sparseResidencyImage3D_ = 0,
+                            vk::Bool32 sparseResidency2Samples_ = 0,
+                            vk::Bool32 sparseResidency4Samples_ = 0,
+                            vk::Bool32 sparseResidency8Samples_ = 0,
+                            vk::Bool32 sparseResidency16Samples_ = 0,
+                            vk::Bool32 sparseResidencyAliased_ = 0,
+                            vk::Bool32 variableMultisampleRate_ = 0,
+                            vk::Bool32 inheritedQueries_ = 0 )
+        : robustBufferAccess( robustBufferAccess_ )
+        , fullDrawIndexUint32( fullDrawIndexUint32_ )
+        , imageCubeArray( imageCubeArray_ )
+        , independentBlend( independentBlend_ )
+        , geometryShader( geometryShader_ )
+        , tessellationShader( tessellationShader_ )
+        , sampleRateShading( sampleRateShading_ )
+        , dualSrcBlend( dualSrcBlend_ )
+        , logicOp( logicOp_ )
+        , multiDrawIndirect( multiDrawIndirect_ )
+        , drawIndirectFirstInstance( drawIndirectFirstInstance_ )
+        , depthClamp( depthClamp_ )
+        , depthBiasClamp( depthBiasClamp_ )
+        , fillModeNonSolid( fillModeNonSolid_ )
+        , depthBounds( depthBounds_ )
+        , wideLines( wideLines_ )
+        , largePoints( largePoints_ )
+        , alphaToOne( alphaToOne_ )
+        , multiViewport( multiViewport_ )
+        , samplerAnisotropy( samplerAnisotropy_ )
+        , textureCompressionETC2( textureCompressionETC2_ )
+        , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ )
+        , textureCompressionBC( textureCompressionBC_ )
+        , occlusionQueryPrecise( occlusionQueryPrecise_ )
+        , pipelineStatisticsQuery( pipelineStatisticsQuery_ )
+        , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ )
+        , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ )
+        , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ )
+        , shaderImageGatherExtended( shaderImageGatherExtended_ )
+        , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ )
+        , shaderStorageImageMultisample( shaderStorageImageMultisample_ )
+        , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ )
+        , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ )
+        , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ )
+        , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ )
+        , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ )
+        , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ )
+        , shaderClipDistance( shaderClipDistance_ )
+        , shaderCullDistance( shaderCullDistance_ )
+        , shaderFloat64( shaderFloat64_ )
+        , shaderInt64( shaderInt64_ )
+        , shaderInt16( shaderInt16_ )
+        , shaderResourceResidency( shaderResourceResidency_ )
+        , shaderResourceMinLod( shaderResourceMinLod_ )
+        , sparseBinding( sparseBinding_ )
+        , sparseResidencyBuffer( sparseResidencyBuffer_ )
+        , sparseResidencyImage2D( sparseResidencyImage2D_ )
+        , sparseResidencyImage3D( sparseResidencyImage3D_ )
+        , sparseResidency2Samples( sparseResidency2Samples_ )
+        , sparseResidency4Samples( sparseResidency4Samples_ )
+        , sparseResidency8Samples( sparseResidency8Samples_ )
+        , sparseResidency16Samples( sparseResidency16Samples_ )
+        , sparseResidencyAliased( sparseResidencyAliased_ )
+        , variableMultisampleRate( variableMultisampleRate_ )
+        , inheritedQueries( inheritedQueries_ )
     {}
 
     PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs )
@@ -25558,331 +28057,331 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceFeatures & setRobustBufferAccess( Bool32 robustBufferAccess_ )
+    PhysicalDeviceFeatures & setRobustBufferAccess( vk::Bool32 robustBufferAccess_ )
     {
       robustBufferAccess = robustBufferAccess_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ )
+    PhysicalDeviceFeatures & setFullDrawIndexUint32( vk::Bool32 fullDrawIndexUint32_ )
     {
       fullDrawIndexUint32 = fullDrawIndexUint32_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setImageCubeArray( Bool32 imageCubeArray_ )
+    PhysicalDeviceFeatures & setImageCubeArray( vk::Bool32 imageCubeArray_ )
     {
       imageCubeArray = imageCubeArray_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setIndependentBlend( Bool32 independentBlend_ )
+    PhysicalDeviceFeatures & setIndependentBlend( vk::Bool32 independentBlend_ )
     {
       independentBlend = independentBlend_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setGeometryShader( Bool32 geometryShader_ )
+    PhysicalDeviceFeatures & setGeometryShader( vk::Bool32 geometryShader_ )
     {
       geometryShader = geometryShader_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setTessellationShader( Bool32 tessellationShader_ )
+    PhysicalDeviceFeatures & setTessellationShader( vk::Bool32 tessellationShader_ )
     {
       tessellationShader = tessellationShader_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSampleRateShading( Bool32 sampleRateShading_ )
+    PhysicalDeviceFeatures & setSampleRateShading( vk::Bool32 sampleRateShading_ )
     {
       sampleRateShading = sampleRateShading_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setDualSrcBlend( Bool32 dualSrcBlend_ )
+    PhysicalDeviceFeatures & setDualSrcBlend( vk::Bool32 dualSrcBlend_ )
     {
       dualSrcBlend = dualSrcBlend_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setLogicOp( Bool32 logicOp_ )
+    PhysicalDeviceFeatures & setLogicOp( vk::Bool32 logicOp_ )
     {
       logicOp = logicOp_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setMultiDrawIndirect( Bool32 multiDrawIndirect_ )
+    PhysicalDeviceFeatures & setMultiDrawIndirect( vk::Bool32 multiDrawIndirect_ )
     {
       multiDrawIndirect = multiDrawIndirect_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ )
+    PhysicalDeviceFeatures & setDrawIndirectFirstInstance( vk::Bool32 drawIndirectFirstInstance_ )
     {
       drawIndirectFirstInstance = drawIndirectFirstInstance_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setDepthClamp( Bool32 depthClamp_ )
+    PhysicalDeviceFeatures & setDepthClamp( vk::Bool32 depthClamp_ )
     {
       depthClamp = depthClamp_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setDepthBiasClamp( Bool32 depthBiasClamp_ )
+    PhysicalDeviceFeatures & setDepthBiasClamp( vk::Bool32 depthBiasClamp_ )
     {
       depthBiasClamp = depthBiasClamp_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setFillModeNonSolid( Bool32 fillModeNonSolid_ )
+    PhysicalDeviceFeatures & setFillModeNonSolid( vk::Bool32 fillModeNonSolid_ )
     {
       fillModeNonSolid = fillModeNonSolid_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setDepthBounds( Bool32 depthBounds_ )
+    PhysicalDeviceFeatures & setDepthBounds( vk::Bool32 depthBounds_ )
     {
       depthBounds = depthBounds_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setWideLines( Bool32 wideLines_ )
+    PhysicalDeviceFeatures & setWideLines( vk::Bool32 wideLines_ )
     {
       wideLines = wideLines_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setLargePoints( Bool32 largePoints_ )
+    PhysicalDeviceFeatures & setLargePoints( vk::Bool32 largePoints_ )
     {
       largePoints = largePoints_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setAlphaToOne( Bool32 alphaToOne_ )
+    PhysicalDeviceFeatures & setAlphaToOne( vk::Bool32 alphaToOne_ )
     {
       alphaToOne = alphaToOne_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setMultiViewport( Bool32 multiViewport_ )
+    PhysicalDeviceFeatures & setMultiViewport( vk::Bool32 multiViewport_ )
     {
       multiViewport = multiViewport_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSamplerAnisotropy( Bool32 samplerAnisotropy_ )
+    PhysicalDeviceFeatures & setSamplerAnisotropy( vk::Bool32 samplerAnisotropy_ )
     {
       samplerAnisotropy = samplerAnisotropy_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setTextureCompressionETC2( Bool32 textureCompressionETC2_ )
+    PhysicalDeviceFeatures & setTextureCompressionETC2( vk::Bool32 textureCompressionETC2_ )
     {
       textureCompressionETC2 = textureCompressionETC2_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ )
+    PhysicalDeviceFeatures & setTextureCompressionASTC_LDR( vk::Bool32 textureCompressionASTC_LDR_ )
     {
       textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setTextureCompressionBC( Bool32 textureCompressionBC_ )
+    PhysicalDeviceFeatures & setTextureCompressionBC( vk::Bool32 textureCompressionBC_ )
     {
       textureCompressionBC = textureCompressionBC_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ )
+    PhysicalDeviceFeatures & setOcclusionQueryPrecise( vk::Bool32 occlusionQueryPrecise_ )
     {
       occlusionQueryPrecise = occlusionQueryPrecise_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ )
+    PhysicalDeviceFeatures & setPipelineStatisticsQuery( vk::Bool32 pipelineStatisticsQuery_ )
     {
       pipelineStatisticsQuery = pipelineStatisticsQuery_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ )
+    PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics( vk::Bool32 vertexPipelineStoresAndAtomics_ )
     {
       vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ )
+    PhysicalDeviceFeatures & setFragmentStoresAndAtomics( vk::Bool32 fragmentStoresAndAtomics_ )
     {
       fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ )
+    PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize( vk::Bool32 shaderTessellationAndGeometryPointSize_ )
     {
       shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ )
+    PhysicalDeviceFeatures & setShaderImageGatherExtended( vk::Bool32 shaderImageGatherExtended_ )
     {
       shaderImageGatherExtended = shaderImageGatherExtended_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ )
+    PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats( vk::Bool32 shaderStorageImageExtendedFormats_ )
     {
       shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ )
+    PhysicalDeviceFeatures & setShaderStorageImageMultisample( vk::Bool32 shaderStorageImageMultisample_ )
     {
       shaderStorageImageMultisample = shaderStorageImageMultisample_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ )
+    PhysicalDeviceFeatures & setShaderStorageImageReadWithoutFormat( vk::Bool32 shaderStorageImageReadWithoutFormat_ )
     {
       shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ )
+    PhysicalDeviceFeatures & setShaderStorageImageWriteWithoutFormat( vk::Bool32 shaderStorageImageWriteWithoutFormat_ )
     {
       shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ )
+    PhysicalDeviceFeatures & setShaderUniformBufferArrayDynamicIndexing( vk::Bool32 shaderUniformBufferArrayDynamicIndexing_ )
     {
       shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ )
+    PhysicalDeviceFeatures & setShaderSampledImageArrayDynamicIndexing( vk::Bool32 shaderSampledImageArrayDynamicIndexing_ )
     {
       shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ )
+    PhysicalDeviceFeatures & setShaderStorageBufferArrayDynamicIndexing( vk::Bool32 shaderStorageBufferArrayDynamicIndexing_ )
     {
       shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ )
+    PhysicalDeviceFeatures & setShaderStorageImageArrayDynamicIndexing( vk::Bool32 shaderStorageImageArrayDynamicIndexing_ )
     {
       shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderClipDistance( Bool32 shaderClipDistance_ )
+    PhysicalDeviceFeatures & setShaderClipDistance( vk::Bool32 shaderClipDistance_ )
     {
       shaderClipDistance = shaderClipDistance_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderCullDistance( Bool32 shaderCullDistance_ )
+    PhysicalDeviceFeatures & setShaderCullDistance( vk::Bool32 shaderCullDistance_ )
     {
       shaderCullDistance = shaderCullDistance_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderFloat64( Bool32 shaderFloat64_ )
+    PhysicalDeviceFeatures & setShaderFloat64( vk::Bool32 shaderFloat64_ )
     {
       shaderFloat64 = shaderFloat64_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderInt64( Bool32 shaderInt64_ )
+    PhysicalDeviceFeatures & setShaderInt64( vk::Bool32 shaderInt64_ )
     {
       shaderInt64 = shaderInt64_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderInt16( Bool32 shaderInt16_ )
+    PhysicalDeviceFeatures & setShaderInt16( vk::Bool32 shaderInt16_ )
     {
       shaderInt16 = shaderInt16_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderResourceResidency( Bool32 shaderResourceResidency_ )
+    PhysicalDeviceFeatures & setShaderResourceResidency( vk::Bool32 shaderResourceResidency_ )
     {
       shaderResourceResidency = shaderResourceResidency_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setShaderResourceMinLod( Bool32 shaderResourceMinLod_ )
+    PhysicalDeviceFeatures & setShaderResourceMinLod( vk::Bool32 shaderResourceMinLod_ )
     {
       shaderResourceMinLod = shaderResourceMinLod_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseBinding( Bool32 sparseBinding_ )
+    PhysicalDeviceFeatures & setSparseBinding( vk::Bool32 sparseBinding_ )
     {
       sparseBinding = sparseBinding_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ )
+    PhysicalDeviceFeatures & setSparseResidencyBuffer( vk::Bool32 sparseResidencyBuffer_ )
     {
       sparseResidencyBuffer = sparseResidencyBuffer_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ )
+    PhysicalDeviceFeatures & setSparseResidencyImage2D( vk::Bool32 sparseResidencyImage2D_ )
     {
       sparseResidencyImage2D = sparseResidencyImage2D_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ )
+    PhysicalDeviceFeatures & setSparseResidencyImage3D( vk::Bool32 sparseResidencyImage3D_ )
     {
       sparseResidencyImage3D = sparseResidencyImage3D_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseResidency2Samples( Bool32 sparseResidency2Samples_ )
+    PhysicalDeviceFeatures & setSparseResidency2Samples( vk::Bool32 sparseResidency2Samples_ )
     {
       sparseResidency2Samples = sparseResidency2Samples_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseResidency4Samples( Bool32 sparseResidency4Samples_ )
+    PhysicalDeviceFeatures & setSparseResidency4Samples( vk::Bool32 sparseResidency4Samples_ )
     {
       sparseResidency4Samples = sparseResidency4Samples_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseResidency8Samples( Bool32 sparseResidency8Samples_ )
+    PhysicalDeviceFeatures & setSparseResidency8Samples( vk::Bool32 sparseResidency8Samples_ )
     {
       sparseResidency8Samples = sparseResidency8Samples_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseResidency16Samples( Bool32 sparseResidency16Samples_ )
+    PhysicalDeviceFeatures & setSparseResidency16Samples( vk::Bool32 sparseResidency16Samples_ )
     {
       sparseResidency16Samples = sparseResidency16Samples_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setSparseResidencyAliased( Bool32 sparseResidencyAliased_ )
+    PhysicalDeviceFeatures & setSparseResidencyAliased( vk::Bool32 sparseResidencyAliased_ )
     {
       sparseResidencyAliased = sparseResidencyAliased_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setVariableMultisampleRate( Bool32 variableMultisampleRate_ )
+    PhysicalDeviceFeatures & setVariableMultisampleRate( vk::Bool32 variableMultisampleRate_ )
     {
       variableMultisampleRate = variableMultisampleRate_;
       return *this;
     }
 
-    PhysicalDeviceFeatures & setInheritedQueries( Bool32 inheritedQueries_ )
+    PhysicalDeviceFeatures & setInheritedQueries( vk::Bool32 inheritedQueries_ )
     {
       inheritedQueries = inheritedQueries_;
       return *this;
@@ -25962,88 +28461,131 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Bool32 robustBufferAccess;
-    Bool32 fullDrawIndexUint32;
-    Bool32 imageCubeArray;
-    Bool32 independentBlend;
-    Bool32 geometryShader;
-    Bool32 tessellationShader;
-    Bool32 sampleRateShading;
-    Bool32 dualSrcBlend;
-    Bool32 logicOp;
-    Bool32 multiDrawIndirect;
-    Bool32 drawIndirectFirstInstance;
-    Bool32 depthClamp;
-    Bool32 depthBiasClamp;
-    Bool32 fillModeNonSolid;
-    Bool32 depthBounds;
-    Bool32 wideLines;
-    Bool32 largePoints;
-    Bool32 alphaToOne;
-    Bool32 multiViewport;
-    Bool32 samplerAnisotropy;
-    Bool32 textureCompressionETC2;
-    Bool32 textureCompressionASTC_LDR;
-    Bool32 textureCompressionBC;
-    Bool32 occlusionQueryPrecise;
-    Bool32 pipelineStatisticsQuery;
-    Bool32 vertexPipelineStoresAndAtomics;
-    Bool32 fragmentStoresAndAtomics;
-    Bool32 shaderTessellationAndGeometryPointSize;
-    Bool32 shaderImageGatherExtended;
-    Bool32 shaderStorageImageExtendedFormats;
-    Bool32 shaderStorageImageMultisample;
-    Bool32 shaderStorageImageReadWithoutFormat;
-    Bool32 shaderStorageImageWriteWithoutFormat;
-    Bool32 shaderUniformBufferArrayDynamicIndexing;
-    Bool32 shaderSampledImageArrayDynamicIndexing;
-    Bool32 shaderStorageBufferArrayDynamicIndexing;
-    Bool32 shaderStorageImageArrayDynamicIndexing;
-    Bool32 shaderClipDistance;
-    Bool32 shaderCullDistance;
-    Bool32 shaderFloat64;
-    Bool32 shaderInt64;
-    Bool32 shaderInt16;
-    Bool32 shaderResourceResidency;
-    Bool32 shaderResourceMinLod;
-    Bool32 sparseBinding;
-    Bool32 sparseResidencyBuffer;
-    Bool32 sparseResidencyImage2D;
-    Bool32 sparseResidencyImage3D;
-    Bool32 sparseResidency2Samples;
-    Bool32 sparseResidency4Samples;
-    Bool32 sparseResidency8Samples;
-    Bool32 sparseResidency16Samples;
-    Bool32 sparseResidencyAliased;
-    Bool32 variableMultisampleRate;
-    Bool32 inheritedQueries;
+  public:
+    vk::Bool32 robustBufferAccess;
+    vk::Bool32 fullDrawIndexUint32;
+    vk::Bool32 imageCubeArray;
+    vk::Bool32 independentBlend;
+    vk::Bool32 geometryShader;
+    vk::Bool32 tessellationShader;
+    vk::Bool32 sampleRateShading;
+    vk::Bool32 dualSrcBlend;
+    vk::Bool32 logicOp;
+    vk::Bool32 multiDrawIndirect;
+    vk::Bool32 drawIndirectFirstInstance;
+    vk::Bool32 depthClamp;
+    vk::Bool32 depthBiasClamp;
+    vk::Bool32 fillModeNonSolid;
+    vk::Bool32 depthBounds;
+    vk::Bool32 wideLines;
+    vk::Bool32 largePoints;
+    vk::Bool32 alphaToOne;
+    vk::Bool32 multiViewport;
+    vk::Bool32 samplerAnisotropy;
+    vk::Bool32 textureCompressionETC2;
+    vk::Bool32 textureCompressionASTC_LDR;
+    vk::Bool32 textureCompressionBC;
+    vk::Bool32 occlusionQueryPrecise;
+    vk::Bool32 pipelineStatisticsQuery;
+    vk::Bool32 vertexPipelineStoresAndAtomics;
+    vk::Bool32 fragmentStoresAndAtomics;
+    vk::Bool32 shaderTessellationAndGeometryPointSize;
+    vk::Bool32 shaderImageGatherExtended;
+    vk::Bool32 shaderStorageImageExtendedFormats;
+    vk::Bool32 shaderStorageImageMultisample;
+    vk::Bool32 shaderStorageImageReadWithoutFormat;
+    vk::Bool32 shaderStorageImageWriteWithoutFormat;
+    vk::Bool32 shaderUniformBufferArrayDynamicIndexing;
+    vk::Bool32 shaderSampledImageArrayDynamicIndexing;
+    vk::Bool32 shaderStorageBufferArrayDynamicIndexing;
+    vk::Bool32 shaderStorageImageArrayDynamicIndexing;
+    vk::Bool32 shaderClipDistance;
+    vk::Bool32 shaderCullDistance;
+    vk::Bool32 shaderFloat64;
+    vk::Bool32 shaderInt64;
+    vk::Bool32 shaderInt16;
+    vk::Bool32 shaderResourceResidency;
+    vk::Bool32 shaderResourceMinLod;
+    vk::Bool32 sparseBinding;
+    vk::Bool32 sparseResidencyBuffer;
+    vk::Bool32 sparseResidencyImage2D;
+    vk::Bool32 sparseResidencyImage3D;
+    vk::Bool32 sparseResidency2Samples;
+    vk::Bool32 sparseResidency4Samples;
+    vk::Bool32 sparseResidency8Samples;
+    vk::Bool32 sparseResidency16Samples;
+    vk::Bool32 sparseResidencyAliased;
+    vk::Bool32 variableMultisampleRate;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct DeviceCreateInfo
+    {
+    protected:
+      DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(),
+                        uint32_t queueCreateInfoCount_ = 0,
+                        const vk::DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr,
+                        uint32_t enabledLayerCount_ = 0,
+                        const char* const* ppEnabledLayerNames_ = nullptr,
+                        uint32_t enabledExtensionCount_ = 0,
+                        const char* const* ppEnabledExtensionNames_ = nullptr,
+                        const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
+        : flags( flags_ )
+        , queueCreateInfoCount( queueCreateInfoCount_ )
+        , pQueueCreateInfos( pQueueCreateInfos_ )
+        , enabledLayerCount( enabledLayerCount_ )
+        , ppEnabledLayerNames( ppEnabledLayerNames_ )
+        , enabledExtensionCount( enabledExtensionCount_ )
+        , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+        , pEnabledFeatures( pEnabledFeatures_ )
+      {}
+
+      DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceCreateInfo*>(this) = rhs;
+      }
 
-  struct DeviceCreateInfo
+      DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceCreateInfo;
+      const void* pNext = nullptr;
+      vk::DeviceCreateFlags flags;
+      uint32_t queueCreateInfoCount;
+      const vk::DeviceQueueCreateInfo* pQueueCreateInfos;
+      uint32_t enabledLayerCount;
+      const char* const* ppEnabledLayerNames;
+      uint32_t enabledExtensionCount;
+      const char* const* ppEnabledExtensionNames;
+      const vk::PhysicalDeviceFeatures* pEnabledFeatures;
+    };
+    static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceCreateInfo : public layout::DeviceCreateInfo
   {
-    DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(),
+    DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(),
                       uint32_t queueCreateInfoCount_ = 0,
-                      const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr,
+                      const vk::DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr,
                       uint32_t enabledLayerCount_ = 0,
                       const char* const* ppEnabledLayerNames_ = nullptr,
                       uint32_t enabledExtensionCount_ = 0,
                       const char* const* ppEnabledExtensionNames_ = nullptr,
-                      const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
-      : flags( flags_ )
-      , queueCreateInfoCount( queueCreateInfoCount_ )
-      , pQueueCreateInfos( pQueueCreateInfos_ )
-      , enabledLayerCount( enabledLayerCount_ )
-      , ppEnabledLayerNames( ppEnabledLayerNames_ )
-      , enabledExtensionCount( enabledExtensionCount_ )
-      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
-      , pEnabledFeatures( pEnabledFeatures_ )
+                      const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
+      : layout::DeviceCreateInfo( flags_, queueCreateInfoCount_, pQueueCreateInfos_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_, pEnabledFeatures_ )
     {}
 
     DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkDeviceCreateInfo*>(this) = rhs;
-    }
+      : layout::DeviceCreateInfo( rhs )
+    {}
 
     DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
     {
@@ -26057,7 +28599,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceCreateInfo & setFlags( DeviceCreateFlags flags_ )
+    DeviceCreateInfo & setFlags( vk::DeviceCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -26069,7 +28611,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceCreateInfo & setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ )
+    DeviceCreateInfo & setPQueueCreateInfos( const vk::DeviceQueueCreateInfo* pQueueCreateInfos_ )
     {
       pQueueCreateInfos = pQueueCreateInfos_;
       return *this;
@@ -26099,7 +28641,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceCreateInfo & setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ )
+    DeviceCreateInfo & setPEnabledFeatures( const vk::PhysicalDeviceFeatures* pEnabledFeatures_ )
     {
       pEnabledFeatures = pEnabledFeatures_;
       return *this;
@@ -26135,31 +28677,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceCreateFlags flags;
-    uint32_t queueCreateInfoCount;
-    const DeviceQueueCreateInfo* pQueueCreateInfos;
-    uint32_t enabledLayerCount;
-    const char* const* ppEnabledLayerNames;
-    uint32_t enabledExtensionCount;
-    const char* const* ppEnabledExtensionNames;
-    const PhysicalDeviceFeatures* pEnabledFeatures;
+    using layout::DeviceCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceEventInfoEXT
+    {
+    protected:
+      DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug )
+        : deviceEvent( deviceEvent_ )
+      {}
+
+      DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDeviceEventInfoEXT*>(this) = rhs;
+      }
+
+      DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDeviceEventInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceEventInfoEXT;
+      const void* pNext = nullptr;
+      vk::DeviceEventTypeEXT deviceEvent;
+    };
+    static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DeviceEventInfoEXT
+  struct DeviceEventInfoEXT : public layout::DeviceEventInfoEXT
   {
-    DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
-      : deviceEvent( deviceEvent_ )
+    DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug )
+      : layout::DeviceEventInfoEXT( deviceEvent_ )
     {}
 
     DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDeviceEventInfoEXT*>(this) = rhs;
-    }
+      : layout::DeviceEventInfoEXT( rhs )
+    {}
 
     DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
     {
@@ -26173,7 +28732,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceEventInfoEXT & setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
+    DeviceEventInfoEXT & setDeviceEvent( vk::DeviceEventTypeEXT deviceEvent_ )
     {
       deviceEvent = deviceEvent_;
       return *this;
@@ -26202,24 +28761,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceEventInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceEventTypeEXT deviceEvent;
+    using layout::DeviceEventInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceGeneratedCommandsFeaturesNVX
+    {
+    protected:
+      DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 )
+        : computeBindingPointSupport( computeBindingPointSupport_ )
+      {}
+
+      DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this) = rhs;
+      }
 
-  struct DeviceGeneratedCommandsFeaturesNVX
+      DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
+      const void* pNext = nullptr;
+      vk::Bool32 computeBindingPointSupport;
+    };
+    static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceGeneratedCommandsFeaturesNVX : public layout::DeviceGeneratedCommandsFeaturesNVX
   {
-    DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 )
-      : computeBindingPointSupport( computeBindingPointSupport_ )
+    DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 )
+      : layout::DeviceGeneratedCommandsFeaturesNVX( computeBindingPointSupport_ )
     {}
 
     DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this) = rhs;
-    }
+      : layout::DeviceGeneratedCommandsFeaturesNVX( rhs )
+    {}
 
     DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
     {
@@ -26233,7 +28816,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceGeneratedCommandsFeaturesNVX & setComputeBindingPointSupport( Bool32 computeBindingPointSupport_ )
+    DeviceGeneratedCommandsFeaturesNVX & setComputeBindingPointSupport( vk::Bool32 computeBindingPointSupport_ )
     {
       computeBindingPointSupport = computeBindingPointSupport_;
       return *this;
@@ -26262,32 +28845,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 computeBindingPointSupport;
+    using layout::DeviceGeneratedCommandsFeaturesNVX::sType;
   };
   static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<DeviceGeneratedCommandsFeaturesNVX>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct DeviceGeneratedCommandsLimitsNVX
+    {
+    protected:
+      DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
+                                        uint32_t maxObjectEntryCounts_ = 0,
+                                        uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
+                                        uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
+                                        uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
+        : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
+        , maxObjectEntryCounts( maxObjectEntryCounts_ )
+        , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
+        , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
+        , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
+      {}
 
-  struct DeviceGeneratedCommandsLimitsNVX
+      DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this) = rhs;
+      }
+
+      DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
+      const void* pNext = nullptr;
+      uint32_t maxIndirectCommandsLayoutTokenCount;
+      uint32_t maxObjectEntryCounts;
+      uint32_t minSequenceCountBufferOffsetAlignment;
+      uint32_t minSequenceIndexBufferOffsetAlignment;
+      uint32_t minCommandsTokenBufferOffsetAlignment;
+    };
+    static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceGeneratedCommandsLimitsNVX : public layout::DeviceGeneratedCommandsLimitsNVX
   {
     DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
                                       uint32_t maxObjectEntryCounts_ = 0,
                                       uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
                                       uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
                                       uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
-      : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
-      , maxObjectEntryCounts( maxObjectEntryCounts_ )
-      , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
-      , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
-      , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
+      : layout::DeviceGeneratedCommandsLimitsNVX( maxIndirectCommandsLayoutTokenCount_, maxObjectEntryCounts_, minSequenceCountBufferOffsetAlignment_, minSequenceIndexBufferOffsetAlignment_, minCommandsTokenBufferOffsetAlignment_ )
     {}
 
     DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this) = rhs;
-    }
+      : layout::DeviceGeneratedCommandsLimitsNVX( rhs )
+    {}
 
     DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
     {
@@ -26358,30 +28973,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t maxIndirectCommandsLayoutTokenCount;
-    uint32_t maxObjectEntryCounts;
-    uint32_t minSequenceCountBufferOffsetAlignment;
-    uint32_t minSequenceIndexBufferOffsetAlignment;
-    uint32_t minCommandsTokenBufferOffsetAlignment;
+    using layout::DeviceGeneratedCommandsLimitsNVX::sType;
   };
   static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<DeviceGeneratedCommandsLimitsNVX>::value, "struct wrapper is not a standard layout!" );
 
-  struct DeviceGroupBindSparseInfo
+  namespace layout
+  {
+    struct DeviceGroupBindSparseInfo
+    {
+    protected:
+      DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
+                                 uint32_t memoryDeviceIndex_ = 0 )
+        : resourceDeviceIndex( resourceDeviceIndex_ )
+        , memoryDeviceIndex( memoryDeviceIndex_ )
+      {}
+
+      DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this) = rhs;
+      }
+
+      DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGroupBindSparseInfo;
+      const void* pNext = nullptr;
+      uint32_t resourceDeviceIndex;
+      uint32_t memoryDeviceIndex;
+    };
+    static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceGroupBindSparseInfo : public layout::DeviceGroupBindSparseInfo
   {
     DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
                                uint32_t memoryDeviceIndex_ = 0 )
-      : resourceDeviceIndex( resourceDeviceIndex_ )
-      , memoryDeviceIndex( memoryDeviceIndex_ )
+      : layout::DeviceGroupBindSparseInfo( resourceDeviceIndex_, memoryDeviceIndex_ )
     {}
 
     DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this) = rhs;
-    }
+      : layout::DeviceGroupBindSparseInfo( rhs )
+    {}
 
     DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs )
     {
@@ -26431,25 +29068,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGroupBindSparseInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t resourceDeviceIndex;
-    uint32_t memoryDeviceIndex;
+    using layout::DeviceGroupBindSparseInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceGroupCommandBufferBeginInfo
+    {
+    protected:
+      DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 )
+        : deviceMask( deviceMask_ )
+      {}
+
+      DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this) = rhs;
+      }
+
+      DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo;
+      const void* pNext = nullptr;
+      uint32_t deviceMask;
+    };
+    static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DeviceGroupCommandBufferBeginInfo
+  struct DeviceGroupCommandBufferBeginInfo : public layout::DeviceGroupCommandBufferBeginInfo
   {
     DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 )
-      : deviceMask( deviceMask_ )
+      : layout::DeviceGroupCommandBufferBeginInfo( deviceMask_ )
     {}
 
     DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this) = rhs;
-    }
+      : layout::DeviceGroupCommandBufferBeginInfo( rhs )
+    {}
 
     DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs )
     {
@@ -26492,26 +29152,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceMask;
+    using layout::DeviceGroupCommandBufferBeginInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceGroupDeviceCreateInfo
+    {
+    protected:
+      DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
+                                   const vk::PhysicalDevice* pPhysicalDevices_ = nullptr )
+        : physicalDeviceCount( physicalDeviceCount_ )
+        , pPhysicalDevices( pPhysicalDevices_ )
+      {}
+
+      DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this) = rhs;
+      }
+
+      DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this) = rhs;
+        return *this;
+      }
 
-  struct DeviceGroupDeviceCreateInfo
+    public:
+      vk::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo;
+      const void* pNext = nullptr;
+      uint32_t physicalDeviceCount;
+      const vk::PhysicalDevice* pPhysicalDevices;
+    };
+    static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceGroupDeviceCreateInfo : public layout::DeviceGroupDeviceCreateInfo
   {
     DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
-                                 const PhysicalDevice* pPhysicalDevices_ = nullptr )
-      : physicalDeviceCount( physicalDeviceCount_ )
-      , pPhysicalDevices( pPhysicalDevices_ )
+                                 const vk::PhysicalDevice* pPhysicalDevices_ = nullptr )
+      : layout::DeviceGroupDeviceCreateInfo( physicalDeviceCount_, pPhysicalDevices_ )
     {}
 
     DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this) = rhs;
-    }
+      : layout::DeviceGroupDeviceCreateInfo( rhs )
+    {}
 
     DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs )
     {
@@ -26531,7 +29217,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceGroupDeviceCreateInfo & setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ )
+    DeviceGroupDeviceCreateInfo & setPPhysicalDevices( const vk::PhysicalDevice* pPhysicalDevices_ )
     {
       pPhysicalDevices = pPhysicalDevices_;
       return *this;
@@ -26561,16 +29247,45 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t physicalDeviceCount;
-    const PhysicalDevice* pPhysicalDevices;
+    using layout::DeviceGroupDeviceCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceGroupPresentCapabilitiesKHR
+    {
+    protected:
+      DeviceGroupPresentCapabilitiesKHR( std::array<uint32_t,VK_MAX_DEVICE_GROUP_SIZE> const& presentMask_ = { { 0 } },
+                                         vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() )
+        : modes( modes_ )
+      {
+        memcpy( &presentMask, presentMask_.data(), VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) );
+      
+      }
+
+      DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this) = rhs;
+      }
 
-  struct DeviceGroupPresentCapabilitiesKHR
+      DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
+      const void* pNext = nullptr;
+      uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+      vk::DeviceGroupPresentModeFlagsKHR modes;
+    };
+    static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceGroupPresentCapabilitiesKHR : public layout::DeviceGroupPresentCapabilitiesKHR
   {
     operator VkDeviceGroupPresentCapabilitiesKHR const&() const
     {
@@ -26596,29 +29311,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
-    DeviceGroupPresentModeFlagsKHR modes;
+    using layout::DeviceGroupPresentCapabilitiesKHR::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceGroupPresentInfoKHR
+    {
+    protected:
+      DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
+                                 const uint32_t* pDeviceMasks_ = nullptr,
+                                 vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal )
+        : swapchainCount( swapchainCount_ )
+        , pDeviceMasks( pDeviceMasks_ )
+        , mode( mode_ )
+      {}
+
+      DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this) = rhs;
+      }
 
-  struct DeviceGroupPresentInfoKHR
+      DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
+      const void* pNext = nullptr;
+      uint32_t swapchainCount;
+      const uint32_t* pDeviceMasks;
+      vk::DeviceGroupPresentModeFlagBitsKHR mode;
+    };
+    static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceGroupPresentInfoKHR : public layout::DeviceGroupPresentInfoKHR
   {
     DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
                                const uint32_t* pDeviceMasks_ = nullptr,
-                               DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal )
-      : swapchainCount( swapchainCount_ )
-      , pDeviceMasks( pDeviceMasks_ )
-      , mode( mode_ )
+                               vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal )
+      : layout::DeviceGroupPresentInfoKHR( swapchainCount_, pDeviceMasks_, mode_ )
     {}
 
     DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this) = rhs;
-    }
+      : layout::DeviceGroupPresentInfoKHR( rhs )
+    {}
 
     DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs )
     {
@@ -26644,7 +29386,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceGroupPresentInfoKHR & setMode( DeviceGroupPresentModeFlagBitsKHR mode_ )
+    DeviceGroupPresentInfoKHR & setMode( vk::DeviceGroupPresentModeFlagBitsKHR mode_ )
     {
       mode = mode_;
       return *this;
@@ -26675,30 +29417,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const uint32_t* pDeviceMasks;
-    DeviceGroupPresentModeFlagBitsKHR mode;
+    using layout::DeviceGroupPresentInfoKHR::sType;
   };
   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!" );
 
-  struct DeviceGroupRenderPassBeginInfo
+  namespace layout
+  {
+    struct DeviceGroupRenderPassBeginInfo
+    {
+    protected:
+      DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
+                                      uint32_t deviceRenderAreaCount_ = 0,
+                                      const vk::Rect2D* pDeviceRenderAreas_ = nullptr )
+        : deviceMask( deviceMask_ )
+        , deviceRenderAreaCount( deviceRenderAreaCount_ )
+        , pDeviceRenderAreas( pDeviceRenderAreas_ )
+      {}
+
+      DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this) = rhs;
+      }
+
+      DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo;
+      const void* pNext = nullptr;
+      uint32_t deviceMask;
+      uint32_t deviceRenderAreaCount;
+      const vk::Rect2D* pDeviceRenderAreas;
+    };
+    static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceGroupRenderPassBeginInfo : public layout::DeviceGroupRenderPassBeginInfo
   {
     DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
                                     uint32_t deviceRenderAreaCount_ = 0,
-                                    const Rect2D* pDeviceRenderAreas_ = nullptr )
-      : deviceMask( deviceMask_ )
-      , deviceRenderAreaCount( deviceRenderAreaCount_ )
-      , pDeviceRenderAreas( pDeviceRenderAreas_ )
+                                    const vk::Rect2D* pDeviceRenderAreas_ = nullptr )
+      : layout::DeviceGroupRenderPassBeginInfo( deviceMask_, deviceRenderAreaCount_, pDeviceRenderAreas_ )
     {}
 
     DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this) = rhs;
-    }
+      : layout::DeviceGroupRenderPassBeginInfo( rhs )
+    {}
 
     DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs )
     {
@@ -26724,7 +29492,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceGroupRenderPassBeginInfo & setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ )
+    DeviceGroupRenderPassBeginInfo & setPDeviceRenderAreas( const vk::Rect2D* pDeviceRenderAreas_ )
     {
       pDeviceRenderAreas = pDeviceRenderAreas_;
       return *this;
@@ -26755,17 +29523,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceMask;
-    uint32_t deviceRenderAreaCount;
-    const Rect2D* pDeviceRenderAreas;
+    using layout::DeviceGroupRenderPassBeginInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceGroupSubmitInfo
+    {
+    protected:
+      DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
+                             const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
+                             uint32_t commandBufferCount_ = 0,
+                             const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
+                             uint32_t signalSemaphoreCount_ = 0,
+                             const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
+        : waitSemaphoreCount( waitSemaphoreCount_ )
+        , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
+        , commandBufferCount( commandBufferCount_ )
+        , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
+        , signalSemaphoreCount( signalSemaphoreCount_ )
+        , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
+      {}
+
+      DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this) = rhs;
+      }
+
+      DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGroupSubmitInfo;
+      const void* pNext = nullptr;
+      uint32_t waitSemaphoreCount;
+      const uint32_t* pWaitSemaphoreDeviceIndices;
+      uint32_t commandBufferCount;
+      const uint32_t* pCommandBufferDeviceMasks;
+      uint32_t signalSemaphoreCount;
+      const uint32_t* pSignalSemaphoreDeviceIndices;
+    };
+    static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DeviceGroupSubmitInfo
+  struct DeviceGroupSubmitInfo : public layout::DeviceGroupSubmitInfo
   {
     DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
                            const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
@@ -26773,18 +29579,12 @@ namespace VULKAN_HPP_NAMESPACE
                            const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
                            uint32_t signalSemaphoreCount_ = 0,
                            const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
-      , commandBufferCount( commandBufferCount_ )
-      , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
+      : layout::DeviceGroupSubmitInfo( waitSemaphoreCount_, pWaitSemaphoreDeviceIndices_, commandBufferCount_, pCommandBufferDeviceMasks_, signalSemaphoreCount_, pSignalSemaphoreDeviceIndices_ )
     {}
 
     DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this) = rhs;
-    }
+      : layout::DeviceGroupSubmitInfo( rhs )
+    {}
 
     DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs )
     {
@@ -26862,29 +29662,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGroupSubmitInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const uint32_t* pWaitSemaphoreDeviceIndices;
-    uint32_t commandBufferCount;
-    const uint32_t* pCommandBufferDeviceMasks;
-    uint32_t signalSemaphoreCount;
-    const uint32_t* pSignalSemaphoreDeviceIndices;
+    using layout::DeviceGroupSubmitInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceGroupSwapchainCreateInfoKHR
+    {
+    protected:
+      DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() )
+        : modes( modes_ )
+      {}
+
+      DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this) = rhs;
+      }
 
-  struct DeviceGroupSwapchainCreateInfoKHR
+      DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::DeviceGroupPresentModeFlagsKHR modes;
+    };
+    static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceGroupSwapchainCreateInfoKHR : public layout::DeviceGroupSwapchainCreateInfoKHR
   {
-    DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = DeviceGroupPresentModeFlagsKHR() )
-      : modes( modes_ )
+    DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() )
+      : layout::DeviceGroupSwapchainCreateInfoKHR( modes_ )
     {}
 
     DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::DeviceGroupSwapchainCreateInfoKHR( rhs )
+    {}
 
     DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
     {
@@ -26898,7 +29717,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceGroupSwapchainCreateInfoKHR & setModes( DeviceGroupPresentModeFlagsKHR modes_ )
+    DeviceGroupSwapchainCreateInfoKHR & setModes( vk::DeviceGroupPresentModeFlagsKHR modes_ )
     {
       modes = modes_;
       return *this;
@@ -26927,24 +29746,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceGroupPresentModeFlagsKHR modes;
+    using layout::DeviceGroupSwapchainCreateInfoKHR::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceMemoryOverallocationCreateInfoAMD
+    {
+    protected:
+      DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault )
+        : overallocationBehavior( overallocationBehavior_ )
+      {}
 
-  struct DeviceMemoryOverallocationCreateInfoAMD
+      DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
+      {
+        *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this) = rhs;
+      }
+
+      DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
+      {
+        *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
+      const void* pNext = nullptr;
+      vk::MemoryOverallocationBehaviorAMD overallocationBehavior;
+    };
+    static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceMemoryOverallocationCreateInfoAMD : public layout::DeviceMemoryOverallocationCreateInfoAMD
   {
-    DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault )
-      : overallocationBehavior( overallocationBehavior_ )
+    DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault )
+      : layout::DeviceMemoryOverallocationCreateInfoAMD( overallocationBehavior_ )
     {}
 
     DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
-    {
-      *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this) = rhs;
-    }
+      : layout::DeviceMemoryOverallocationCreateInfoAMD( rhs )
+    {}
 
     DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
     {
@@ -26958,7 +29801,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ )
+    DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ )
     {
       overallocationBehavior = overallocationBehavior_;
       return *this;
@@ -26987,24 +29830,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
-
-  public:
-    const void* pNext = nullptr;
-    MemoryOverallocationBehaviorAMD overallocationBehavior;
+    using layout::DeviceMemoryOverallocationCreateInfoAMD::sType;
   };
   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!" );
 
-  struct DeviceQueueGlobalPriorityCreateInfoEXT
+  namespace layout
   {
-    DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
-      : globalPriority( globalPriority_ )
+    struct DeviceQueueGlobalPriorityCreateInfoEXT
+    {
+    protected:
+      DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow )
+        : globalPriority( globalPriority_ )
+      {}
+
+      DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this) = rhs;
+      }
+
+      DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::QueueGlobalPriorityEXT globalPriority;
+    };
+    static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DeviceQueueGlobalPriorityCreateInfoEXT : public layout::DeviceQueueGlobalPriorityCreateInfoEXT
+  {
+    DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow )
+      : layout::DeviceQueueGlobalPriorityCreateInfoEXT( globalPriority_ )
     {}
 
     DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::DeviceQueueGlobalPriorityCreateInfoEXT( rhs )
+    {}
 
     DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
     {
@@ -27018,7 +29885,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceQueueGlobalPriorityCreateInfoEXT & setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ )
+    DeviceQueueGlobalPriorityCreateInfoEXT & setGlobalPriority( vk::QueueGlobalPriorityEXT globalPriority_ )
     {
       globalPriority = globalPriority_;
       return *this;
@@ -27047,28 +29914,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    QueueGlobalPriorityEXT globalPriority;
+    using layout::DeviceQueueGlobalPriorityCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DeviceQueueInfo2
+    {
+    protected:
+      DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
+                        uint32_t queueFamilyIndex_ = 0,
+                        uint32_t queueIndex_ = 0 )
+        : flags( flags_ )
+        , queueFamilyIndex( queueFamilyIndex_ )
+        , queueIndex( queueIndex_ )
+      {}
+
+      DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkDeviceQueueInfo2*>(this) = rhs;
+      }
+
+      DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkDeviceQueueInfo2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDeviceQueueInfo2;
+      const void* pNext = nullptr;
+      vk::DeviceQueueCreateFlags flags;
+      uint32_t queueFamilyIndex;
+      uint32_t queueIndex;
+    };
+    static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DeviceQueueInfo2
+  struct DeviceQueueInfo2 : public layout::DeviceQueueInfo2
   {
-    DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
+    DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
                       uint32_t queueFamilyIndex_ = 0,
                       uint32_t queueIndex_ = 0 )
-      : flags( flags_ )
-      , queueFamilyIndex( queueFamilyIndex_ )
-      , queueIndex( queueIndex_ )
+      : layout::DeviceQueueInfo2( flags_, queueFamilyIndex_, queueIndex_ )
     {}
 
     DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs )
-    {
-      *reinterpret_cast<VkDeviceQueueInfo2*>(this) = rhs;
-    }
+      : layout::DeviceQueueInfo2( rhs )
+    {}
 
     DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs )
     {
@@ -27082,7 +29977,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DeviceQueueInfo2 & setFlags( DeviceQueueCreateFlags flags_ )
+    DeviceQueueInfo2 & setFlags( vk::DeviceQueueCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -27125,24 +30020,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDeviceQueueInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceQueueCreateFlags flags;
-    uint32_t queueFamilyIndex;
-    uint32_t queueIndex;
+    using layout::DeviceQueueInfo2::sType;
   };
   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!" );
 
   struct DispatchIndirectCommand
   {
     DispatchIndirectCommand( uint32_t x_ = 0,
                              uint32_t y_ = 0,
                              uint32_t z_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
+        : x( x_ )
+        , y( y_ )
+        , z( z_ )
     {}
 
     DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs )
@@ -27196,22 +30086,51 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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!" );
+
+  namespace layout
+  {
+    struct DisplayEventInfoEXT
+    {
+    protected:
+      DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut )
+        : displayEvent( displayEvent_ )
+      {}
+
+      DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDisplayEventInfoEXT*>(this) = rhs;
+      }
 
-  struct DisplayEventInfoEXT
+      DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDisplayEventInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplayEventInfoEXT;
+      const void* pNext = nullptr;
+      vk::DisplayEventTypeEXT displayEvent;
+    };
+    static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayEventInfoEXT : public layout::DisplayEventInfoEXT
   {
-    DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
-      : displayEvent( displayEvent_ )
+    DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut )
+      : layout::DisplayEventInfoEXT( displayEvent_ )
     {}
 
     DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDisplayEventInfoEXT*>(this) = rhs;
-    }
+      : layout::DisplayEventInfoEXT( rhs )
+    {}
 
     DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
     {
@@ -27225,7 +30144,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayEventInfoEXT & setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
+    DisplayEventInfoEXT & setDisplayEvent( vk::DisplayEventTypeEXT displayEvent_ )
     {
       displayEvent = displayEvent_;
       return *this;
@@ -27254,20 +30173,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayEventInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayEventTypeEXT displayEvent;
+    using layout::DisplayEventInfoEXT::sType;
   };
   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!" );
 
   struct DisplayModeParametersKHR
   {
-    DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(),
+    DisplayModeParametersKHR( vk::Extent2D visibleRegion_ = vk::Extent2D(),
                               uint32_t refreshRate_ = 0 )
-      : visibleRegion( visibleRegion_ )
-      , refreshRate( refreshRate_ )
+        : visibleRegion( visibleRegion_ )
+        , refreshRate( refreshRate_ )
     {}
 
     DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs )
@@ -27281,7 +30197,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayModeParametersKHR & setVisibleRegion( Extent2D visibleRegion_ )
+    DisplayModeParametersKHR & setVisibleRegion( vk::Extent2D visibleRegion_ )
     {
       visibleRegion = visibleRegion_;
       return *this;
@@ -27314,23 +30230,54 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Extent2D visibleRegion;
+  public:
+    vk::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!" );
+
+  namespace layout
+  {
+    struct DisplayModeCreateInfoKHR
+    {
+    protected:
+      DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(),
+                                vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() )
+        : flags( flags_ )
+        , parameters( parameters_ )
+      {}
+
+      DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this) = rhs;
+      }
+
+      DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct DisplayModeCreateInfoKHR
+    public:
+      vk::StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::DisplayModeCreateFlagsKHR flags;
+      vk::DisplayModeParametersKHR parameters;
+    };
+    static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayModeCreateInfoKHR : public layout::DisplayModeCreateInfoKHR
   {
-    DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(),
-                              DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() )
-      : flags( flags_ )
-      , parameters( parameters_ )
+    DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(),
+                              vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() )
+      : layout::DisplayModeCreateInfoKHR( flags_, parameters_ )
     {}
 
     DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::DisplayModeCreateInfoKHR( rhs )
+    {}
 
     DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
     {
@@ -27344,13 +30291,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayModeCreateInfoKHR & setFlags( DisplayModeCreateFlagsKHR flags_ )
+    DisplayModeCreateInfoKHR & setFlags( vk::DisplayModeCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    DisplayModeCreateInfoKHR & setParameters( DisplayModeParametersKHR parameters_ )
+    DisplayModeCreateInfoKHR & setParameters( vk::DisplayModeParametersKHR parameters_ )
     {
       parameters = parameters_;
       return *this;
@@ -27380,14 +30327,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayModeCreateFlagsKHR flags;
-    DisplayModeParametersKHR parameters;
+    using layout::DisplayModeCreateInfoKHR::sType;
   };
   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!" );
 
   struct DisplayModePropertiesKHR
   {
@@ -27412,12 +30355,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DisplayModeKHR displayMode;
-    DisplayModeParametersKHR parameters;
+  public:
+    vk::DisplayModeKHR displayMode;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct DisplayModeProperties2KHR
+    {
+    protected:
+      DisplayModeProperties2KHR( vk::DisplayModePropertiesKHR displayModeProperties_ = vk::DisplayModePropertiesKHR() )
+        : displayModeProperties( displayModeProperties_ )
+      {}
+
+      DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayModeProperties2KHR*>(this) = rhs;
+      }
+
+      DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayModeProperties2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplayModeProperties2KHR;
+      void* pNext = nullptr;
+      vk::DisplayModePropertiesKHR displayModeProperties;
+    };
+    static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct DisplayModeProperties2KHR
+  struct DisplayModeProperties2KHR : public layout::DisplayModeProperties2KHR
   {
     operator VkDisplayModeProperties2KHR const&() const
     {
@@ -27442,15 +30415,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayModeProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    DisplayModePropertiesKHR displayModeProperties;
+    using layout::DisplayModeProperties2KHR::sType;
   };
   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!" );
 
-  struct DisplayNativeHdrSurfaceCapabilitiesAMD
+  namespace layout
+  {
+    struct DisplayNativeHdrSurfaceCapabilitiesAMD
+    {
+    protected:
+      DisplayNativeHdrSurfaceCapabilitiesAMD( vk::Bool32 localDimmingSupport_ = 0 )
+        : localDimmingSupport( localDimmingSupport_ )
+      {}
+
+      DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs )
+      {
+        *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(this) = rhs;
+      }
+
+      DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs )
+      {
+        *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD;
+      void* pNext = nullptr;
+      vk::Bool32 localDimmingSupport;
+    };
+    static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayNativeHdrSurfaceCapabilitiesAMD : public layout::DisplayNativeHdrSurfaceCapabilitiesAMD
   {
     operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const&() const
     {
@@ -27475,13 +30473,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 localDimmingSupport;
+    using layout::DisplayNativeHdrSurfaceCapabilitiesAMD::sType;
   };
   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!" );
 
   struct DisplayPlaneCapabilitiesKHR
   {
@@ -27513,19 +30508,49 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DisplayPlaneAlphaFlagsKHR supportedAlpha;
-    Offset2D minSrcPosition;
-    Offset2D maxSrcPosition;
-    Extent2D minSrcExtent;
-    Extent2D maxSrcExtent;
-    Offset2D minDstPosition;
-    Offset2D maxDstPosition;
-    Extent2D minDstExtent;
-    Extent2D maxDstExtent;
+  public:
+    vk::DisplayPlaneAlphaFlagsKHR supportedAlpha;
+    vk::Offset2D minSrcPosition;
+    vk::Offset2D maxSrcPosition;
+    vk::Extent2D minSrcExtent;
+    vk::Extent2D maxSrcExtent;
+    vk::Offset2D minDstPosition;
+    vk::Offset2D maxDstPosition;
+    vk::Extent2D minDstExtent;
+    vk::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
+  namespace layout
+  {
+    struct DisplayPlaneCapabilities2KHR
+    {
+    protected:
+      DisplayPlaneCapabilities2KHR( vk::DisplayPlaneCapabilitiesKHR capabilities_ = vk::DisplayPlaneCapabilitiesKHR() )
+        : capabilities( capabilities_ )
+      {}
+
+      DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this) = rhs;
+      }
+
+      DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
+      void* pNext = nullptr;
+      vk::DisplayPlaneCapabilitiesKHR capabilities;
+    };
+    static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayPlaneCapabilities2KHR : public layout::DisplayPlaneCapabilities2KHR
   {
     operator VkDisplayPlaneCapabilities2KHR const&() const
     {
@@ -27550,26 +30575,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
-
-  public:
-    void* pNext = nullptr;
-    DisplayPlaneCapabilitiesKHR capabilities;
+    using layout::DisplayPlaneCapabilities2KHR::sType;
   };
   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!" );
 
-  struct DisplayPlaneInfo2KHR
+  namespace layout
   {
-    DisplayPlaneInfo2KHR( DisplayModeKHR mode_ = DisplayModeKHR(),
+    struct DisplayPlaneInfo2KHR
+    {
+    protected:
+      DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(),
+                            uint32_t planeIndex_ = 0 )
+        : mode( mode_ )
+        , planeIndex( planeIndex_ )
+      {}
+
+      DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this) = rhs;
+      }
+
+      DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
+      const void* pNext = nullptr;
+      vk::DisplayModeKHR mode;
+      uint32_t planeIndex;
+    };
+    static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayPlaneInfo2KHR : public layout::DisplayPlaneInfo2KHR
+  {
+    DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(),
                           uint32_t planeIndex_ = 0 )
-      : mode( mode_ )
-      , planeIndex( planeIndex_ )
+      : layout::DisplayPlaneInfo2KHR( mode_, planeIndex_ )
     {}
 
     DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs )
-    {
-      *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this) = rhs;
-    }
+      : layout::DisplayPlaneInfo2KHR( rhs )
+    {}
 
     DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs )
     {
@@ -27583,7 +30634,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayPlaneInfo2KHR & setMode( DisplayModeKHR mode_ )
+    DisplayPlaneInfo2KHR & setMode( vk::DisplayModeKHR mode_ )
     {
       mode = mode_;
       return *this;
@@ -27619,14 +30670,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayModeKHR mode;
-    uint32_t planeIndex;
+    using layout::DisplayPlaneInfo2KHR::sType;
   };
   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!" );
 
   struct DisplayPlanePropertiesKHR
   {
@@ -27651,12 +30698,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DisplayKHR currentDisplay;
+  public:
+    vk::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!" );
+
+  namespace layout
+  {
+    struct DisplayPlaneProperties2KHR
+    {
+    protected:
+      DisplayPlaneProperties2KHR( vk::DisplayPlanePropertiesKHR displayPlaneProperties_ = vk::DisplayPlanePropertiesKHR() )
+        : displayPlaneProperties( displayPlaneProperties_ )
+      {}
+
+      DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this) = rhs;
+      }
+
+      DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct DisplayPlaneProperties2KHR
+    public:
+      vk::StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
+      void* pNext = nullptr;
+      vk::DisplayPlanePropertiesKHR displayPlaneProperties;
+    };
+    static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayPlaneProperties2KHR : public layout::DisplayPlaneProperties2KHR
   {
     operator VkDisplayPlaneProperties2KHR const&() const
     {
@@ -27681,24 +30758,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    DisplayPlanePropertiesKHR displayPlaneProperties;
+    using layout::DisplayPlaneProperties2KHR::sType;
   };
   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!" );
 
-  struct DisplayPowerInfoEXT
+  namespace layout
   {
-    DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
-      : powerState( powerState_ )
+    struct DisplayPowerInfoEXT
+    {
+    protected:
+      DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff )
+        : powerState( powerState_ )
+      {}
+
+      DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPowerInfoEXT*>(this) = rhs;
+      }
+
+      DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPowerInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplayPowerInfoEXT;
+      const void* pNext = nullptr;
+      vk::DisplayPowerStateEXT powerState;
+    };
+    static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayPowerInfoEXT : public layout::DisplayPowerInfoEXT
+  {
+    DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff )
+      : layout::DisplayPowerInfoEXT( powerState_ )
     {}
 
     DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkDisplayPowerInfoEXT*>(this) = rhs;
-    }
+      : layout::DisplayPowerInfoEXT( rhs )
+    {}
 
     DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
     {
@@ -27712,7 +30813,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayPowerInfoEXT & setPowerState( DisplayPowerStateEXT powerState_ )
+    DisplayPowerInfoEXT & setPowerState( vk::DisplayPowerStateEXT powerState_ )
     {
       powerState = powerState_;
       return *this;
@@ -27741,28 +30842,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayPowerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayPowerStateEXT powerState;
+    using layout::DisplayPowerInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct DisplayPresentInfoKHR
+    {
+    protected:
+      DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(),
+                             vk::Rect2D dstRect_ = vk::Rect2D(),
+                             vk::Bool32 persistent_ = 0 )
+        : srcRect( srcRect_ )
+        , dstRect( dstRect_ )
+        , persistent( persistent_ )
+      {}
 
-  struct DisplayPresentInfoKHR
+      DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPresentInfoKHR*>(this) = rhs;
+      }
+
+      DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayPresentInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplayPresentInfoKHR;
+      const void* pNext = nullptr;
+      vk::Rect2D srcRect;
+      vk::Rect2D dstRect;
+      vk::Bool32 persistent;
+    };
+    static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayPresentInfoKHR : public layout::DisplayPresentInfoKHR
   {
-    DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(),
-                           Rect2D dstRect_ = Rect2D(),
-                           Bool32 persistent_ = 0 )
-      : srcRect( srcRect_ )
-      , dstRect( dstRect_ )
-      , persistent( persistent_ )
+    DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(),
+                           vk::Rect2D dstRect_ = vk::Rect2D(),
+                           vk::Bool32 persistent_ = 0 )
+      : layout::DisplayPresentInfoKHR( srcRect_, dstRect_, persistent_ )
     {}
 
     DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkDisplayPresentInfoKHR*>(this) = rhs;
-    }
+      : layout::DisplayPresentInfoKHR( rhs )
+    {}
 
     DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
     {
@@ -27776,19 +30905,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplayPresentInfoKHR & setSrcRect( Rect2D srcRect_ )
+    DisplayPresentInfoKHR & setSrcRect( vk::Rect2D srcRect_ )
     {
       srcRect = srcRect_;
       return *this;
     }
 
-    DisplayPresentInfoKHR & setDstRect( Rect2D dstRect_ )
+    DisplayPresentInfoKHR & setDstRect( vk::Rect2D dstRect_ )
     {
       dstRect = dstRect_;
       return *this;
     }
 
-    DisplayPresentInfoKHR & setPersistent( Bool32 persistent_ )
+    DisplayPresentInfoKHR & setPersistent( vk::Bool32 persistent_ )
     {
       persistent = persistent_;
       return *this;
@@ -27819,15 +30948,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayPresentInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Rect2D srcRect;
-    Rect2D dstRect;
-    Bool32 persistent;
+    using layout::DisplayPresentInfoKHR::sType;
   };
   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!" );
 
   struct DisplayPropertiesKHR
   {
@@ -27857,17 +30981,47 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DisplayKHR display;
+  public:
+    vk::DisplayKHR display;
     const char* displayName;
-    Extent2D physicalDimensions;
-    Extent2D physicalResolution;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    Bool32 planeReorderPossible;
-    Bool32 persistentContent;
+    vk::Extent2D physicalDimensions;
+    vk::Extent2D physicalResolution;
+    vk::SurfaceTransformFlagsKHR supportedTransforms;
+    vk::Bool32 planeReorderPossible;
+    vk::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
+  namespace layout
+  {
+    struct DisplayProperties2KHR
+    {
+    protected:
+      DisplayProperties2KHR( vk::DisplayPropertiesKHR displayProperties_ = vk::DisplayPropertiesKHR() )
+        : displayProperties( displayProperties_ )
+      {}
+
+      DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayProperties2KHR*>(this) = rhs;
+      }
+
+      DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplayProperties2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplayProperties2KHR;
+      void* pNext = nullptr;
+      vk::DisplayPropertiesKHR displayProperties;
+    };
+    static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplayProperties2KHR : public layout::DisplayProperties2KHR
   {
     operator VkDisplayProperties2KHR const&() const
     {
@@ -27892,38 +31046,76 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplayProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    DisplayPropertiesKHR displayProperties;
+    using layout::DisplayProperties2KHR::sType;
   };
   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!" );
 
-  struct DisplaySurfaceCreateInfoKHR
+  namespace layout
   {
-    DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(),
-                                 DisplayModeKHR displayMode_ = DisplayModeKHR(),
+    struct DisplaySurfaceCreateInfoKHR
+    {
+    protected:
+      DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(),
+                                   vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(),
+                                   uint32_t planeIndex_ = 0,
+                                   uint32_t planeStackIndex_ = 0,
+                                   vk::SurfaceTransformFlagBitsKHR transform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
+                                   float globalAlpha_ = 0,
+                                   vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque,
+                                   vk::Extent2D imageExtent_ = vk::Extent2D() )
+        : flags( flags_ )
+        , displayMode( displayMode_ )
+        , planeIndex( planeIndex_ )
+        , planeStackIndex( planeStackIndex_ )
+        , transform( transform_ )
+        , globalAlpha( globalAlpha_ )
+        , alphaMode( alphaMode_ )
+        , imageExtent( imageExtent_ )
+      {}
+
+      DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this) = rhs;
+      }
+
+      DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::DisplaySurfaceCreateFlagsKHR flags;
+      vk::DisplayModeKHR displayMode;
+      uint32_t planeIndex;
+      uint32_t planeStackIndex;
+      vk::SurfaceTransformFlagBitsKHR transform;
+      float globalAlpha;
+      vk::DisplayPlaneAlphaFlagBitsKHR alphaMode;
+      vk::Extent2D imageExtent;
+    };
+    static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DisplaySurfaceCreateInfoKHR : public layout::DisplaySurfaceCreateInfoKHR
+  {
+    DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(),
+                                 vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(),
                                  uint32_t planeIndex_ = 0,
                                  uint32_t planeStackIndex_ = 0,
-                                 SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity,
+                                 vk::SurfaceTransformFlagBitsKHR transform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
                                  float globalAlpha_ = 0,
-                                 DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque,
-                                 Extent2D imageExtent_ = Extent2D() )
-      : flags( flags_ )
-      , displayMode( displayMode_ )
-      , planeIndex( planeIndex_ )
-      , planeStackIndex( planeStackIndex_ )
-      , transform( transform_ )
-      , globalAlpha( globalAlpha_ )
-      , alphaMode( alphaMode_ )
-      , imageExtent( imageExtent_ )
+                                 vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque,
+                                 vk::Extent2D imageExtent_ = vk::Extent2D() )
+      : layout::DisplaySurfaceCreateInfoKHR( flags_, displayMode_, planeIndex_, planeStackIndex_, transform_, globalAlpha_, alphaMode_, imageExtent_ )
     {}
 
     DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::DisplaySurfaceCreateInfoKHR( rhs )
+    {}
 
     DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
     {
@@ -27937,13 +31129,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplaySurfaceCreateInfoKHR & setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
+    DisplaySurfaceCreateInfoKHR & setFlags( vk::DisplaySurfaceCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    DisplaySurfaceCreateInfoKHR & setDisplayMode( DisplayModeKHR displayMode_ )
+    DisplaySurfaceCreateInfoKHR & setDisplayMode( vk::DisplayModeKHR displayMode_ )
     {
       displayMode = displayMode_;
       return *this;
@@ -27961,7 +31153,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplaySurfaceCreateInfoKHR & setTransform( SurfaceTransformFlagBitsKHR transform_ )
+    DisplaySurfaceCreateInfoKHR & setTransform( vk::SurfaceTransformFlagBitsKHR transform_ )
     {
       transform = transform_;
       return *this;
@@ -27973,13 +31165,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    DisplaySurfaceCreateInfoKHR & setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
+    DisplaySurfaceCreateInfoKHR & setAlphaMode( vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
     {
       alphaMode = alphaMode_;
       return *this;
     }
 
-    DisplaySurfaceCreateInfoKHR & setImageExtent( Extent2D imageExtent_ )
+    DisplaySurfaceCreateInfoKHR & setImageExtent( vk::Extent2D imageExtent_ )
     {
       imageExtent = imageExtent_;
       return *this;
@@ -28015,20 +31207,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DisplaySurfaceCreateFlagsKHR flags;
-    DisplayModeKHR displayMode;
-    uint32_t planeIndex;
-    uint32_t planeStackIndex;
-    SurfaceTransformFlagBitsKHR transform;
-    float globalAlpha;
-    DisplayPlaneAlphaFlagBitsKHR alphaMode;
-    Extent2D imageExtent;
+    using layout::DisplaySurfaceCreateInfoKHR::sType;
   };
   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!" );
 
   struct DrawIndexedIndirectCommand
   {
@@ -28037,11 +31219,11 @@ namespace VULKAN_HPP_NAMESPACE
                                 uint32_t firstIndex_ = 0,
                                 int32_t vertexOffset_ = 0,
                                 uint32_t firstInstance_ = 0 )
-      : indexCount( indexCount_ )
-      , instanceCount( instanceCount_ )
-      , firstIndex( firstIndex_ )
-      , vertexOffset( vertexOffset_ )
-      , firstInstance( firstInstance_ )
+        : indexCount( indexCount_ )
+        , instanceCount( instanceCount_ )
+        , firstIndex( firstIndex_ )
+        , vertexOffset( vertexOffset_ )
+        , firstInstance( firstInstance_ )
     {}
 
     DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs )
@@ -28109,6 +31291,7 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t indexCount;
     uint32_t instanceCount;
     uint32_t firstIndex;
@@ -28116,6 +31299,7 @@ namespace VULKAN_HPP_NAMESPACE
     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
   {
@@ -28123,10 +31307,10 @@ namespace VULKAN_HPP_NAMESPACE
                          uint32_t instanceCount_ = 0,
                          uint32_t firstVertex_ = 0,
                          uint32_t firstInstance_ = 0 )
-      : vertexCount( vertexCount_ )
-      , instanceCount( instanceCount_ )
-      , firstVertex( firstVertex_ )
-      , firstInstance( firstInstance_ )
+        : vertexCount( vertexCount_ )
+        , instanceCount( instanceCount_ )
+        , firstVertex( firstVertex_ )
+        , firstInstance( firstInstance_ )
     {}
 
     DrawIndirectCommand( VkDrawIndirectCommand const & rhs )
@@ -28187,19 +31371,21 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
   {
     DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0,
                                     uint32_t firstTask_ = 0 )
-      : taskCount( taskCount_ )
-      , firstTask( firstTask_ )
+        : taskCount( taskCount_ )
+        , firstTask( firstTask_ )
     {}
 
     DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs )
@@ -28246,10 +31432,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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
   {
@@ -28275,13 +31463,46 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint64_t drmFormatModifier;
     uint32_t drmFormatModifierPlaneCount;
-    FormatFeatureFlags drmFormatModifierTilingFeatures;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct DrmFormatModifierPropertiesListEXT
+    {
+    protected:
+      DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = 0,
+                                          vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = nullptr )
+        : drmFormatModifierCount( drmFormatModifierCount_ )
+        , pDrmFormatModifierProperties( pDrmFormatModifierProperties_ )
+      {}
+
+      DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs )
+      {
+        *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this) = rhs;
+      }
+
+      DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs )
+      {
+        *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct DrmFormatModifierPropertiesListEXT
+    public:
+      vk::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
+      void* pNext = nullptr;
+      uint32_t drmFormatModifierCount;
+      vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
+    };
+    static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct DrmFormatModifierPropertiesListEXT : public layout::DrmFormatModifierPropertiesListEXT
   {
     operator VkDrmFormatModifierPropertiesListEXT const&() const
     {
@@ -28307,25 +31528,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t drmFormatModifierCount;
-    DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
+    using layout::DrmFormatModifierPropertiesListEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct EventCreateInfo
+    {
+    protected:
+      EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() )
+        : flags( flags_ )
+      {}
+
+      EventCreateInfo( VkEventCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkEventCreateInfo*>(this) = rhs;
+      }
+
+      EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkEventCreateInfo*>(this) = rhs;
+        return *this;
+      }
 
-  struct EventCreateInfo
+    public:
+      vk::StructureType sType = StructureType::eEventCreateInfo;
+      const void* pNext = nullptr;
+      vk::EventCreateFlags flags;
+    };
+    static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct EventCreateInfo : public layout::EventCreateInfo
   {
-    EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() )
-      : flags( flags_ )
+    EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() )
+      : layout::EventCreateInfo( flags_ )
     {}
 
     EventCreateInfo( VkEventCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkEventCreateInfo*>(this) = rhs;
-    }
+      : layout::EventCreateInfo( rhs )
+    {}
 
     EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
     {
@@ -28339,7 +31583,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    EventCreateInfo & setFlags( EventCreateFlags flags_ )
+    EventCreateInfo & setFlags( vk::EventCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -28368,24 +31612,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eEventCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    EventCreateFlags flags;
+    using layout::EventCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ExportFenceCreateInfo
+    {
+    protected:
+      ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() )
+        : handleTypes( handleTypes_ )
+      {}
 
-  struct ExportFenceCreateInfo
+      ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExportFenceCreateInfo*>(this) = rhs;
+      }
+
+      ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExportFenceCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExportFenceCreateInfo;
+      const void* pNext = nullptr;
+      vk::ExternalFenceHandleTypeFlags handleTypes;
+    };
+    static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExportFenceCreateInfo : public layout::ExportFenceCreateInfo
   {
-    ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = ExternalFenceHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
+    ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() )
+      : layout::ExportFenceCreateInfo( handleTypes_ )
     {}
 
     ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkExportFenceCreateInfo*>(this) = rhs;
-    }
+      : layout::ExportFenceCreateInfo( rhs )
+    {}
 
     ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs )
     {
@@ -28399,7 +31667,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ExportFenceCreateInfo & setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ )
+    ExportFenceCreateInfo & setHandleTypes( vk::ExternalFenceHandleTypeFlags handleTypes_ )
     {
       handleTypes = handleTypes_;
       return *this;
@@ -28428,29 +31696,58 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExportFenceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalFenceHandleTypeFlags handleTypes;
+    using layout::ExportFenceCreateInfo::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportFenceWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct ExportFenceWin32HandleInfoKHR
+    {
+    protected:
+      ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+                                     DWORD dwAccess_ = 0,
+                                     LPCWSTR name_ = nullptr )
+        : pAttributes( pAttributes_ )
+        , dwAccess( dwAccess_ )
+        , name( name_ )
+      {}
+
+      ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      const SECURITY_ATTRIBUTES* pAttributes;
+      DWORD dwAccess;
+      LPCWSTR name;
+    };
+    static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExportFenceWin32HandleInfoKHR : public layout::ExportFenceWin32HandleInfoKHR
   {
     ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
                                    DWORD dwAccess_ = 0,
                                    LPCWSTR name_ = nullptr )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
+      : layout::ExportFenceWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
     {}
 
     ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::ExportFenceWin32HandleInfoKHR( rhs )
+    {}
 
     ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs )
     {
@@ -28507,27 +31804,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
+    using layout::ExportFenceWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct ExportMemoryAllocateInfo
+  namespace layout
+  {
+    struct ExportMemoryAllocateInfo
+    {
+    protected:
+      ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+        : handleTypes( handleTypes_ )
+      {}
+
+      ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExportMemoryAllocateInfo*>(this) = rhs;
+      }
+
+      ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExportMemoryAllocateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExportMemoryAllocateInfo;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlags handleTypes;
+    };
+    static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExportMemoryAllocateInfo : public layout::ExportMemoryAllocateInfo
   {
-    ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
+    ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+      : layout::ExportMemoryAllocateInfo( handleTypes_ )
     {}
 
     ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs )
-    {
-      *reinterpret_cast<VkExportMemoryAllocateInfo*>(this) = rhs;
-    }
+      : layout::ExportMemoryAllocateInfo( rhs )
+    {}
 
     ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs )
     {
@@ -28541,7 +31860,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ExportMemoryAllocateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+    ExportMemoryAllocateInfo & setHandleTypes( vk::ExternalMemoryHandleTypeFlags handleTypes_ )
     {
       handleTypes = handleTypes_;
       return *this;
@@ -28570,24 +31889,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExportMemoryAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlags handleTypes;
+    using layout::ExportMemoryAllocateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ExportMemoryAllocateInfoNV
+    {
+    protected:
+      ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() )
+        : handleTypes( handleTypes_ )
+      {}
+
+      ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this) = rhs;
+      }
+
+      ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct ExportMemoryAllocateInfoNV
+    public:
+      vk::StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlagsNV handleTypes;
+    };
+    static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExportMemoryAllocateInfoNV : public layout::ExportMemoryAllocateInfoNV
   {
-    ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
-      : handleTypes( handleTypes_ )
+    ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() )
+      : layout::ExportMemoryAllocateInfoNV( handleTypes_ )
     {}
 
     ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this) = rhs;
-    }
+      : layout::ExportMemoryAllocateInfoNV( rhs )
+    {}
 
     ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
     {
@@ -28601,7 +31944,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ExportMemoryAllocateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+    ExportMemoryAllocateInfoNV & setHandleTypes( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ )
     {
       handleTypes = handleTypes_;
       return *this;
@@ -28630,29 +31973,58 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleTypes;
+    using layout::ExportMemoryAllocateInfoNV::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportMemoryWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct ExportMemoryWin32HandleInfoKHR
+    {
+    protected:
+      ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+                                      DWORD dwAccess_ = 0,
+                                      LPCWSTR name_ = nullptr )
+        : pAttributes( pAttributes_ )
+        , dwAccess( dwAccess_ )
+        , name( name_ )
+      {}
+
+      ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      const SECURITY_ATTRIBUTES* pAttributes;
+      DWORD dwAccess;
+      LPCWSTR name;
+    };
+    static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExportMemoryWin32HandleInfoKHR : public layout::ExportMemoryWin32HandleInfoKHR
   {
     ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
                                     DWORD dwAccess_ = 0,
                                     LPCWSTR name_ = nullptr )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
+      : layout::ExportMemoryWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
     {}
 
     ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::ExportMemoryWin32HandleInfoKHR( rhs )
+    {}
 
     ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs )
     {
@@ -28709,30 +32081,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
+    using layout::ExportMemoryWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportMemoryWin32HandleInfoNV
+
+  namespace layout
+  {
+    struct ExportMemoryWin32HandleInfoNV
+    {
+    protected:
+      ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+                                     DWORD dwAccess_ = 0 )
+        : pAttributes( pAttributes_ )
+        , dwAccess( dwAccess_ )
+      {}
+
+      ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this) = rhs;
+      }
+
+      ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
+      const void* pNext = nullptr;
+      const SECURITY_ATTRIBUTES* pAttributes;
+      DWORD dwAccess;
+    };
+    static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExportMemoryWin32HandleInfoNV : public layout::ExportMemoryWin32HandleInfoNV
   {
     ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
                                    DWORD dwAccess_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
+      : layout::ExportMemoryWin32HandleInfoNV( pAttributes_, dwAccess_ )
     {}
 
     ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this) = rhs;
-    }
+      : layout::ExportMemoryWin32HandleInfoNV( rhs )
+    {}
 
     ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
     {
@@ -28782,26 +32179,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
+    using layout::ExportMemoryWin32HandleInfoNV::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct ExportSemaphoreCreateInfo
+  namespace layout
+  {
+    struct ExportSemaphoreCreateInfo
+    {
+    protected:
+      ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() )
+        : handleTypes( handleTypes_ )
+      {}
+
+      ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this) = rhs;
+      }
+
+      ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExportSemaphoreCreateInfo;
+      const void* pNext = nullptr;
+      vk::ExternalSemaphoreHandleTypeFlags handleTypes;
+    };
+    static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExportSemaphoreCreateInfo : public layout::ExportSemaphoreCreateInfo
   {
-    ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = ExternalSemaphoreHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
+    ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() )
+      : layout::ExportSemaphoreCreateInfo( handleTypes_ )
     {}
 
     ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this) = rhs;
-    }
+      : layout::ExportSemaphoreCreateInfo( rhs )
+    {}
 
     ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs )
     {
@@ -28815,7 +32235,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ExportSemaphoreCreateInfo & setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ )
+    ExportSemaphoreCreateInfo & setHandleTypes( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ )
     {
       handleTypes = handleTypes_;
       return *this;
@@ -28844,29 +32264,58 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExportSemaphoreCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlags handleTypes;
+    using layout::ExportSemaphoreCreateInfo::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportSemaphoreWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct ExportSemaphoreWin32HandleInfoKHR
+    {
+    protected:
+      ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+                                         DWORD dwAccess_ = 0,
+                                         LPCWSTR name_ = nullptr )
+        : pAttributes( pAttributes_ )
+        , dwAccess( dwAccess_ )
+        , name( name_ )
+      {}
+
+      ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      const SECURITY_ATTRIBUTES* pAttributes;
+      DWORD dwAccess;
+      LPCWSTR name;
+    };
+    static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExportSemaphoreWin32HandleInfoKHR : public layout::ExportSemaphoreWin32HandleInfoKHR
   {
     ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
                                        DWORD dwAccess_ = 0,
                                        LPCWSTR name_ = nullptr )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
+      : layout::ExportSemaphoreWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
     {}
 
     ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::ExportSemaphoreWin32HandleInfoKHR( rhs )
+    {}
 
     ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
     {
@@ -28923,15 +32372,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
+    using layout::ExportSemaphoreWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct ExtensionProperties
@@ -28957,10 +32401,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
     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
   {
@@ -28986,13 +32432,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ExternalMemoryFeatureFlags externalMemoryFeatures;
-    ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
-    ExternalMemoryHandleTypeFlags compatibleHandleTypes;
+  public:
+    vk::ExternalMemoryFeatureFlags externalMemoryFeatures;
+    vk::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct ExternalBufferProperties
+    {
+    protected:
+      ExternalBufferProperties( vk::ExternalMemoryProperties externalMemoryProperties_ = vk::ExternalMemoryProperties() )
+        : externalMemoryProperties( externalMemoryProperties_ )
+      {}
 
-  struct ExternalBufferProperties
+      ExternalBufferProperties( VkExternalBufferProperties const & rhs )
+      {
+        *reinterpret_cast<VkExternalBufferProperties*>(this) = rhs;
+      }
+
+      ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs )
+      {
+        *reinterpret_cast<VkExternalBufferProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExternalBufferProperties;
+      void* pNext = nullptr;
+      vk::ExternalMemoryProperties externalMemoryProperties;
+    };
+    static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExternalBufferProperties : public layout::ExternalBufferProperties
   {
     operator VkExternalBufferProperties const&() const
     {
@@ -29017,15 +32493,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExternalBufferProperties;
-
-  public:
-    void* pNext = nullptr;
-    ExternalMemoryProperties externalMemoryProperties;
+    using layout::ExternalBufferProperties::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ExternalFenceProperties
+    {
+    protected:
+      ExternalFenceProperties( vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalFenceHandleTypeFlags(),
+                               vk::ExternalFenceHandleTypeFlags compatibleHandleTypes_ = vk::ExternalFenceHandleTypeFlags(),
+                               vk::ExternalFenceFeatureFlags externalFenceFeatures_ = vk::ExternalFenceFeatureFlags() )
+        : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ )
+        , compatibleHandleTypes( compatibleHandleTypes_ )
+        , externalFenceFeatures( externalFenceFeatures_ )
+      {}
 
-  struct ExternalFenceProperties
+      ExternalFenceProperties( VkExternalFenceProperties const & rhs )
+      {
+        *reinterpret_cast<VkExternalFenceProperties*>(this) = rhs;
+      }
+
+      ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs )
+      {
+        *reinterpret_cast<VkExternalFenceProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExternalFenceProperties;
+      void* pNext = nullptr;
+      vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
+      vk::ExternalFenceHandleTypeFlags compatibleHandleTypes;
+      vk::ExternalFenceFeatureFlags externalFenceFeatures;
+    };
+    static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExternalFenceProperties : public layout::ExternalFenceProperties
   {
     operator VkExternalFenceProperties const&() const
     {
@@ -29052,27 +32559,50 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExternalFenceProperties;
-
-  public:
-    void* pNext = nullptr;
-    ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
-    ExternalFenceHandleTypeFlags compatibleHandleTypes;
-    ExternalFenceFeatureFlags externalFenceFeatures;
+    using layout::ExternalFenceProperties::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct ExternalFormatANDROID
+
+  namespace layout
+  {
+    struct ExternalFormatANDROID
+    {
+    protected:
+      ExternalFormatANDROID( uint64_t externalFormat_ = 0 )
+        : externalFormat( externalFormat_ )
+      {}
+
+      ExternalFormatANDROID( VkExternalFormatANDROID const & rhs )
+      {
+        *reinterpret_cast<VkExternalFormatANDROID*>(this) = rhs;
+      }
+
+      ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs )
+      {
+        *reinterpret_cast<VkExternalFormatANDROID*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExternalFormatANDROID;
+      void* pNext = nullptr;
+      uint64_t externalFormat;
+    };
+    static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExternalFormatANDROID : public layout::ExternalFormatANDROID
   {
     ExternalFormatANDROID( uint64_t externalFormat_ = 0 )
-      : externalFormat( externalFormat_ )
+      : layout::ExternalFormatANDROID( externalFormat_ )
     {}
 
     ExternalFormatANDROID( VkExternalFormatANDROID const & rhs )
-    {
-      *reinterpret_cast<VkExternalFormatANDROID*>(this) = rhs;
-    }
+      : layout::ExternalFormatANDROID( rhs )
+    {}
 
     ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs )
     {
@@ -29115,16 +32645,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExternalFormatANDROID;
-
-  public:
-    void* pNext = nullptr;
-    uint64_t externalFormat;
+    using layout::ExternalFormatANDROID::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  struct ExternalImageFormatProperties
+  namespace layout
+  {
+    struct ExternalImageFormatProperties
+    {
+    protected:
+      ExternalImageFormatProperties( vk::ExternalMemoryProperties externalMemoryProperties_ = vk::ExternalMemoryProperties() )
+        : externalMemoryProperties( externalMemoryProperties_ )
+      {}
+
+      ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs )
+      {
+        *reinterpret_cast<VkExternalImageFormatProperties*>(this) = rhs;
+      }
+
+      ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs )
+      {
+        *reinterpret_cast<VkExternalImageFormatProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExternalImageFormatProperties;
+      void* pNext = nullptr;
+      vk::ExternalMemoryProperties externalMemoryProperties;
+    };
+    static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExternalImageFormatProperties : public layout::ExternalImageFormatProperties
   {
     operator VkExternalImageFormatProperties const&() const
     {
@@ -29149,13 +32704,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExternalImageFormatProperties;
-
-  public:
-    void* pNext = nullptr;
-    ExternalMemoryProperties externalMemoryProperties;
+    using layout::ExternalImageFormatProperties::sType;
   };
   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!" );
 
   struct ImageFormatProperties
   {
@@ -29183,13 +32735,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Extent3D maxExtent;
+  public:
+    vk::Extent3D maxExtent;
     uint32_t maxMipLevels;
     uint32_t maxArrayLayers;
-    SampleCountFlags sampleCounts;
-    DeviceSize maxResourceSize;
+    vk::SampleCountFlags sampleCounts;
+    vk::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
   {
@@ -29216,23 +32770,52 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageFormatProperties imageFormatProperties;
-    ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
-    ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
-    ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
+  public:
+    vk::ImageFormatProperties imageFormatProperties;
+    vk::ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
+    vk::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct ExternalMemoryBufferCreateInfo
+    {
+    protected:
+      ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+        : handleTypes( handleTypes_ )
+      {}
+
+      ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this) = rhs;
+      }
+
+      ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this) = rhs;
+        return *this;
+      }
 
-  struct ExternalMemoryBufferCreateInfo
+    public:
+      vk::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlags handleTypes;
+    };
+    static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExternalMemoryBufferCreateInfo : public layout::ExternalMemoryBufferCreateInfo
   {
-    ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
+    ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+      : layout::ExternalMemoryBufferCreateInfo( handleTypes_ )
     {}
 
     ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this) = rhs;
-    }
+      : layout::ExternalMemoryBufferCreateInfo( rhs )
+    {}
 
     ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs )
     {
@@ -29246,7 +32829,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ExternalMemoryBufferCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+    ExternalMemoryBufferCreateInfo & setHandleTypes( vk::ExternalMemoryHandleTypeFlags handleTypes_ )
     {
       handleTypes = handleTypes_;
       return *this;
@@ -29275,24 +32858,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlags handleTypes;
+    using layout::ExternalMemoryBufferCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ExternalMemoryImageCreateInfo
+    {
+    protected:
+      ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+        : handleTypes( handleTypes_ )
+      {}
+
+      ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this) = rhs;
+      }
 
-  struct ExternalMemoryImageCreateInfo
+      ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlags handleTypes;
+    };
+    static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExternalMemoryImageCreateInfo : public layout::ExternalMemoryImageCreateInfo
   {
-    ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
+    ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+      : layout::ExternalMemoryImageCreateInfo( handleTypes_ )
     {}
 
     ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this) = rhs;
-    }
+      : layout::ExternalMemoryImageCreateInfo( rhs )
+    {}
 
     ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs )
     {
@@ -29306,7 +32913,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ExternalMemoryImageCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+    ExternalMemoryImageCreateInfo & setHandleTypes( vk::ExternalMemoryHandleTypeFlags handleTypes_ )
     {
       handleTypes = handleTypes_;
       return *this;
@@ -29335,24 +32942,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlags handleTypes;
+    using layout::ExternalMemoryImageCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ExternalMemoryImageCreateInfoNV
+    {
+    protected:
+      ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() )
+        : handleTypes( handleTypes_ )
+      {}
+
+      ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this) = rhs;
+      }
 
-  struct ExternalMemoryImageCreateInfoNV
+      ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlagsNV handleTypes;
+    };
+    static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExternalMemoryImageCreateInfoNV : public layout::ExternalMemoryImageCreateInfoNV
   {
-    ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
-      : handleTypes( handleTypes_ )
+    ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() )
+      : layout::ExternalMemoryImageCreateInfoNV( handleTypes_ )
     {}
 
     ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this) = rhs;
-    }
+      : layout::ExternalMemoryImageCreateInfoNV( rhs )
+    {}
 
     ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
     {
@@ -29366,7 +32997,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ExternalMemoryImageCreateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+    ExternalMemoryImageCreateInfoNV & setHandleTypes( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ )
     {
       handleTypes = handleTypes_;
       return *this;
@@ -29395,15 +33026,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleTypes;
+    using layout::ExternalMemoryImageCreateInfoNV::sType;
   };
   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!" );
 
-  struct ExternalSemaphoreProperties
+  namespace layout
+  {
+    struct ExternalSemaphoreProperties
+    {
+    protected:
+      ExternalSemaphoreProperties( vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalSemaphoreHandleTypeFlags(),
+                                   vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = vk::ExternalSemaphoreHandleTypeFlags(),
+                                   vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures_ = vk::ExternalSemaphoreFeatureFlags() )
+        : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ )
+        , compatibleHandleTypes( compatibleHandleTypes_ )
+        , externalSemaphoreFeatures( externalSemaphoreFeatures_ )
+      {}
+
+      ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs )
+      {
+        *reinterpret_cast<VkExternalSemaphoreProperties*>(this) = rhs;
+      }
+
+      ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs )
+      {
+        *reinterpret_cast<VkExternalSemaphoreProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eExternalSemaphoreProperties;
+      void* pNext = nullptr;
+      vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
+      vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
+      vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
+    };
+    static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ExternalSemaphoreProperties : public layout::ExternalSemaphoreProperties
   {
     operator VkExternalSemaphoreProperties const&() const
     {
@@ -29430,26 +33092,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eExternalSemaphoreProperties;
-
-  public:
-    void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
-    ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
-    ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
+    using layout::ExternalSemaphoreProperties::sType;
   };
   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!" );
 
-  struct FenceCreateInfo
+  namespace layout
   {
-    FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
-      : flags( flags_ )
+    struct FenceCreateInfo
+    {
+    protected:
+      FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() )
+        : flags( flags_ )
+      {}
+
+      FenceCreateInfo( VkFenceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkFenceCreateInfo*>(this) = rhs;
+      }
+
+      FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkFenceCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eFenceCreateInfo;
+      const void* pNext = nullptr;
+      vk::FenceCreateFlags flags;
+    };
+    static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct FenceCreateInfo : public layout::FenceCreateInfo
+  {
+    FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() )
+      : layout::FenceCreateInfo( flags_ )
     {}
 
     FenceCreateInfo( VkFenceCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkFenceCreateInfo*>(this) = rhs;
-    }
+      : layout::FenceCreateInfo( rhs )
+    {}
 
     FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
     {
@@ -29463,7 +33147,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    FenceCreateInfo & setFlags( FenceCreateFlags flags_ )
+    FenceCreateInfo & setFlags( vk::FenceCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -29492,26 +33176,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFenceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    FenceCreateFlags flags;
+    using layout::FenceCreateInfo::sType;
   };
   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!" );
 
-  struct FenceGetFdInfoKHR
+  namespace layout
   {
-    FenceGetFdInfoKHR( Fence fence_ = Fence(),
-                       ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
-      : fence( fence_ )
-      , handleType( handleType_ )
+    struct FenceGetFdInfoKHR
+    {
+    protected:
+      FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(),
+                         vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+        : fence( fence_ )
+        , handleType( handleType_ )
+      {}
+
+      FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkFenceGetFdInfoKHR*>(this) = rhs;
+      }
+
+      FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkFenceGetFdInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eFenceGetFdInfoKHR;
+      const void* pNext = nullptr;
+      vk::Fence fence;
+      vk::ExternalFenceHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct FenceGetFdInfoKHR : public layout::FenceGetFdInfoKHR
+  {
+    FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(),
+                       vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+      : layout::FenceGetFdInfoKHR( fence_, handleType_ )
     {}
 
     FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkFenceGetFdInfoKHR*>(this) = rhs;
-    }
+      : layout::FenceGetFdInfoKHR( rhs )
+    {}
 
     FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
     {
@@ -29525,13 +33235,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    FenceGetFdInfoKHR & setFence( Fence fence_ )
+    FenceGetFdInfoKHR & setFence( vk::Fence fence_ )
     {
       fence = fence_;
       return *this;
     }
 
-    FenceGetFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    FenceGetFdInfoKHR & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -29561,28 +33271,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFenceGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    ExternalFenceHandleTypeFlagBits handleType;
+    using layout::FenceGetFdInfoKHR::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct FenceGetWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct FenceGetWin32HandleInfoKHR
+    {
+    protected:
+      FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
+                                  vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+        : fence( fence_ )
+        , handleType( handleType_ )
+      {}
+
+      FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      vk::Fence fence;
+      vk::ExternalFenceHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct FenceGetWin32HandleInfoKHR : public layout::FenceGetWin32HandleInfoKHR
   {
-    FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(),
-                                ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
-      : fence( fence_ )
-      , handleType( handleType_ )
+    FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
+                                vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+      : layout::FenceGetWin32HandleInfoKHR( fence_, handleType_ )
     {}
 
     FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::FenceGetWin32HandleInfoKHR( rhs )
+    {}
 
     FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
     {
@@ -29596,13 +33332,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    FenceGetWin32HandleInfoKHR & setFence( Fence fence_ )
+    FenceGetWin32HandleInfoKHR & setFence( vk::Fence fence_ )
     {
       fence = fence_;
       return *this;
     }
 
-    FenceGetWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    FenceGetWin32HandleInfoKHR & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -29632,17 +33368,44 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    ExternalFenceHandleTypeFlagBits handleType;
+    using layout::FenceGetWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct FilterCubicImageViewImageFormatPropertiesEXT
+  namespace layout
+  {
+    struct FilterCubicImageViewImageFormatPropertiesEXT
+    {
+    protected:
+      FilterCubicImageViewImageFormatPropertiesEXT( vk::Bool32 filterCubic_ = 0,
+                                                    vk::Bool32 filterCubicMinmax_ = 0 )
+        : filterCubic( filterCubic_ )
+        , filterCubicMinmax( filterCubicMinmax_ )
+      {}
+
+      FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(this) = rhs;
+      }
+
+      FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 filterCubic;
+      vk::Bool32 filterCubicMinmax;
+    };
+    static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct FilterCubicImageViewImageFormatPropertiesEXT : public layout::FilterCubicImageViewImageFormatPropertiesEXT
   {
     operator VkFilterCubicImageViewImageFormatPropertiesEXT const&() const
     {
@@ -29668,14 +33431,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 filterCubic;
-    Bool32 filterCubicMinmax;
+    using layout::FilterCubicImageViewImageFormatPropertiesEXT::sType;
   };
   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!" );
 
   struct FormatProperties
   {
@@ -29701,13 +33460,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    FormatFeatureFlags linearTilingFeatures;
-    FormatFeatureFlags optimalTilingFeatures;
-    FormatFeatureFlags bufferFeatures;
+  public:
+    vk::FormatFeatureFlags linearTilingFeatures;
+    vk::FormatFeatureFlags optimalTilingFeatures;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct FormatProperties2
+    {
+    protected:
+      FormatProperties2( vk::FormatProperties formatProperties_ = vk::FormatProperties() )
+        : formatProperties( formatProperties_ )
+      {}
+
+      FormatProperties2( VkFormatProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkFormatProperties2*>(this) = rhs;
+      }
+
+      FormatProperties2& operator=( VkFormatProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkFormatProperties2*>(this) = rhs;
+        return *this;
+      }
 
-  struct FormatProperties2
+    public:
+      vk::StructureType sType = StructureType::eFormatProperties2;
+      void* pNext = nullptr;
+      vk::FormatProperties formatProperties;
+    };
+    static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct FormatProperties2 : public layout::FormatProperties2
   {
     operator VkFormatProperties2 const&() const
     {
@@ -29732,36 +33521,72 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFormatProperties2;
-
-  public:
-    void* pNext = nullptr;
-    FormatProperties formatProperties;
+    using layout::FormatProperties2::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct FramebufferAttachmentImageInfoKHR
+    {
+    protected:
+      FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
+                                         vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+                                         uint32_t width_ = 0,
+                                         uint32_t height_ = 0,
+                                         uint32_t layerCount_ = 0,
+                                         uint32_t viewFormatCount_ = 0,
+                                         const vk::Format* pViewFormats_ = nullptr )
+        : flags( flags_ )
+        , usage( usage_ )
+        , width( width_ )
+        , height( height_ )
+        , layerCount( layerCount_ )
+        , viewFormatCount( viewFormatCount_ )
+        , pViewFormats( pViewFormats_ )
+      {}
+
+      FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
+      }
+
+      FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct FramebufferAttachmentImageInfoKHR
+    public:
+      vk::StructureType sType = StructureType::eFramebufferAttachmentImageInfoKHR;
+      const void* pNext = nullptr;
+      vk::ImageCreateFlags flags;
+      vk::ImageUsageFlags usage;
+      uint32_t width;
+      uint32_t height;
+      uint32_t layerCount;
+      uint32_t viewFormatCount;
+      const vk::Format* pViewFormats;
+    };
+    static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct FramebufferAttachmentImageInfoKHR : public layout::FramebufferAttachmentImageInfoKHR
   {
-    FramebufferAttachmentImageInfoKHR( ImageCreateFlags flags_ = ImageCreateFlags(),
-                                       ImageUsageFlags usage_ = ImageUsageFlags(),
+    FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
+                                       vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
                                        uint32_t width_ = 0,
                                        uint32_t height_ = 0,
                                        uint32_t layerCount_ = 0,
                                        uint32_t viewFormatCount_ = 0,
-                                       const Format* pViewFormats_ = nullptr )
-      : flags( flags_ )
-      , usage( usage_ )
-      , width( width_ )
-      , height( height_ )
-      , layerCount( layerCount_ )
-      , viewFormatCount( viewFormatCount_ )
-      , pViewFormats( pViewFormats_ )
+                                       const vk::Format* pViewFormats_ = nullptr )
+      : layout::FramebufferAttachmentImageInfoKHR( flags_, usage_, width_, height_, layerCount_, viewFormatCount_, pViewFormats_ )
     {}
 
     FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
-    }
+      : layout::FramebufferAttachmentImageInfoKHR( rhs )
+    {}
 
     FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs )
     {
@@ -29775,13 +33600,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    FramebufferAttachmentImageInfoKHR & setFlags( ImageCreateFlags flags_ )
+    FramebufferAttachmentImageInfoKHR & setFlags( vk::ImageCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    FramebufferAttachmentImageInfoKHR & setUsage( ImageUsageFlags usage_ )
+    FramebufferAttachmentImageInfoKHR & setUsage( vk::ImageUsageFlags usage_ )
     {
       usage = usage_;
       return *this;
@@ -29811,7 +33636,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    FramebufferAttachmentImageInfoKHR & setPViewFormats( const Format* pViewFormats_ )
+    FramebufferAttachmentImageInfoKHR & setPViewFormats( const vk::Format* pViewFormats_ )
     {
       pViewFormats = pViewFormats_;
       return *this;
@@ -29846,32 +33671,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFramebufferAttachmentImageInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ImageCreateFlags flags;
-    ImageUsageFlags usage;
-    uint32_t width;
-    uint32_t height;
-    uint32_t layerCount;
-    uint32_t viewFormatCount;
-    const Format* pViewFormats;
+    using layout::FramebufferAttachmentImageInfoKHR::sType;
   };
   static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<FramebufferAttachmentImageInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct FramebufferAttachmentsCreateInfoKHR
+    {
+    protected:
+      FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0,
+                                           const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr )
+        : attachmentImageInfoCount( attachmentImageInfoCount_ )
+        , pAttachmentImageInfos( pAttachmentImageInfos_ )
+      {}
+
+      FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
+      }
+
+      FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR;
+      const void* pNext = nullptr;
+      uint32_t attachmentImageInfoCount;
+      const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos;
+    };
+    static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct FramebufferAttachmentsCreateInfoKHR
+  struct FramebufferAttachmentsCreateInfoKHR : public layout::FramebufferAttachmentsCreateInfoKHR
   {
     FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0,
-                                         const FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr )
-      : attachmentImageInfoCount( attachmentImageInfoCount_ )
-      , pAttachmentImageInfos( pAttachmentImageInfos_ )
+                                         const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr )
+      : layout::FramebufferAttachmentsCreateInfoKHR( attachmentImageInfoCount_, pAttachmentImageInfos_ )
     {}
 
     FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::FramebufferAttachmentsCreateInfoKHR( rhs )
+    {}
 
     FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
     {
@@ -29891,7 +33736,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    FramebufferAttachmentsCreateInfoKHR & setPAttachmentImageInfos( const FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ )
+    FramebufferAttachmentsCreateInfoKHR & setPAttachmentImageInfos( const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ )
     {
       pAttachmentImageInfos = pAttachmentImageInfos_;
       return *this;
@@ -29921,37 +33766,72 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t attachmentImageInfoCount;
-    const FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos;
+    using layout::FramebufferAttachmentsCreateInfoKHR::sType;
   };
   static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<FramebufferAttachmentsCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct FramebufferCreateInfo
+    {
+    protected:
+      FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(),
+                             vk::RenderPass renderPass_ = vk::RenderPass(),
+                             uint32_t attachmentCount_ = 0,
+                             const vk::ImageView* pAttachments_ = nullptr,
+                             uint32_t width_ = 0,
+                             uint32_t height_ = 0,
+                             uint32_t layers_ = 0 )
+        : flags( flags_ )
+        , renderPass( renderPass_ )
+        , attachmentCount( attachmentCount_ )
+        , pAttachments( pAttachments_ )
+        , width( width_ )
+        , height( height_ )
+        , layers( layers_ )
+      {}
+
+      FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkFramebufferCreateInfo*>(this) = rhs;
+      }
 
-  struct FramebufferCreateInfo
+      FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkFramebufferCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eFramebufferCreateInfo;
+      const void* pNext = nullptr;
+      vk::FramebufferCreateFlags flags;
+      vk::RenderPass renderPass;
+      uint32_t attachmentCount;
+      const vk::ImageView* pAttachments;
+      uint32_t width;
+      uint32_t height;
+      uint32_t layers;
+    };
+    static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct FramebufferCreateInfo : public layout::FramebufferCreateInfo
   {
-    FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(),
-                           RenderPass renderPass_ = RenderPass(),
+    FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(),
+                           vk::RenderPass renderPass_ = vk::RenderPass(),
                            uint32_t attachmentCount_ = 0,
-                           const ImageView* pAttachments_ = nullptr,
+                           const vk::ImageView* pAttachments_ = nullptr,
                            uint32_t width_ = 0,
                            uint32_t height_ = 0,
                            uint32_t layers_ = 0 )
-      : flags( flags_ )
-      , renderPass( renderPass_ )
-      , attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
-      , width( width_ )
-      , height( height_ )
-      , layers( layers_ )
+      : layout::FramebufferCreateInfo( flags_, renderPass_, attachmentCount_, pAttachments_, width_, height_, layers_ )
     {}
 
     FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkFramebufferCreateInfo*>(this) = rhs;
-    }
+      : layout::FramebufferCreateInfo( rhs )
+    {}
 
     FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
     {
@@ -29965,13 +33845,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    FramebufferCreateInfo & setFlags( FramebufferCreateFlags flags_ )
+    FramebufferCreateInfo & setFlags( vk::FramebufferCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    FramebufferCreateInfo & setRenderPass( RenderPass renderPass_ )
+    FramebufferCreateInfo & setRenderPass( vk::RenderPass renderPass_ )
     {
       renderPass = renderPass_;
       return *this;
@@ -29983,7 +33863,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    FramebufferCreateInfo & setPAttachments( const ImageView* pAttachments_ )
+    FramebufferCreateInfo & setPAttachments( const vk::ImageView* pAttachments_ )
     {
       pAttachments = pAttachments_;
       return *this;
@@ -30036,21 +33916,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFramebufferCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    FramebufferCreateFlags flags;
-    RenderPass renderPass;
-    uint32_t attachmentCount;
-    const ImageView* pAttachments;
-    uint32_t width;
-    uint32_t height;
-    uint32_t layers;
+    using layout::FramebufferCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct FramebufferMixedSamplesCombinationNV
+    {
+    protected:
+      FramebufferMixedSamplesCombinationNV( vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge,
+                                            vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1,
+                                            vk::SampleCountFlags depthStencilSamples_ = vk::SampleCountFlags(),
+                                            vk::SampleCountFlags colorSamples_ = vk::SampleCountFlags() )
+        : coverageReductionMode( coverageReductionMode_ )
+        , rasterizationSamples( rasterizationSamples_ )
+        , depthStencilSamples( depthStencilSamples_ )
+        , colorSamples( colorSamples_ )
+      {}
+
+      FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs )
+      {
+        *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(this) = rhs;
+      }
+
+      FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs )
+      {
+        *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct FramebufferMixedSamplesCombinationNV
+    public:
+      vk::StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV;
+      void* pNext = nullptr;
+      vk::CoverageReductionModeNV coverageReductionMode;
+      vk::SampleCountFlagBits rasterizationSamples;
+      vk::SampleCountFlags depthStencilSamples;
+      vk::SampleCountFlags colorSamples;
+    };
+    static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct FramebufferMixedSamplesCombinationNV : public layout::FramebufferMixedSamplesCombinationNV
   {
     operator VkFramebufferMixedSamplesCombinationNV const&() const
     {
@@ -30078,25 +33986,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV;
-
-  public:
-    void* pNext = nullptr;
-    CoverageReductionModeNV coverageReductionMode;
-    SampleCountFlagBits rasterizationSamples;
-    SampleCountFlags depthStencilSamples;
-    SampleCountFlags colorSamples;
+    using layout::FramebufferMixedSamplesCombinationNV::sType;
   };
   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!" );
 
   struct VertexInputBindingDescription
   {
     VertexInputBindingDescription( uint32_t binding_ = 0,
                                    uint32_t stride_ = 0,
-                                   VertexInputRate inputRate_ = VertexInputRate::eVertex )
-      : binding( binding_ )
-      , stride( stride_ )
-      , inputRate( inputRate_ )
+                                   vk::VertexInputRate inputRate_ = vk::VertexInputRate::eVertex )
+        : binding( binding_ )
+        , stride( stride_ )
+        , inputRate( inputRate_ )
     {}
 
     VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs )
@@ -30122,7 +34024,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    VertexInputBindingDescription & setInputRate( VertexInputRate inputRate_ )
+    VertexInputBindingDescription & setInputRate( vk::VertexInputRate inputRate_ )
     {
       inputRate = inputRate_;
       return *this;
@@ -30150,22 +34052,24 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t binding;
     uint32_t stride;
-    VertexInputRate inputRate;
+    vk::VertexInputRate inputRate;
   };
   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
   {
     VertexInputAttributeDescription( uint32_t location_ = 0,
                                      uint32_t binding_ = 0,
-                                     Format format_ = Format::eUndefined,
+                                     vk::Format format_ = vk::Format::eUndefined,
                                      uint32_t offset_ = 0 )
-      : location( location_ )
-      , binding( binding_ )
-      , format( format_ )
-      , offset( offset_ )
+        : location( location_ )
+        , binding( binding_ )
+        , format( format_ )
+        , offset( offset_ )
     {}
 
     VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs )
@@ -30191,7 +34095,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    VertexInputAttributeDescription & setFormat( Format format_ )
+    VertexInputAttributeDescription & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
@@ -30226,31 +34130,68 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t location;
     uint32_t binding;
-    Format format;
+    vk::Format format;
     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
+  namespace layout
   {
-    PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(),
+    struct PipelineVertexInputStateCreateInfo
+    {
+    protected:
+      PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(),
+                                          uint32_t vertexBindingDescriptionCount_ = 0,
+                                          const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
+                                          uint32_t vertexAttributeDescriptionCount_ = 0,
+                                          const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
+        : flags( flags_ )
+        , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
+        , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
+        , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
+        , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
+      {}
+
+      PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineVertexInputStateCreateFlags flags;
+      uint32_t vertexBindingDescriptionCount;
+      const vk::VertexInputBindingDescription* pVertexBindingDescriptions;
+      uint32_t vertexAttributeDescriptionCount;
+      const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions;
+    };
+    static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineVertexInputStateCreateInfo : public layout::PipelineVertexInputStateCreateInfo
+  {
+    PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(),
                                         uint32_t vertexBindingDescriptionCount_ = 0,
-                                        const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
+                                        const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
                                         uint32_t vertexAttributeDescriptionCount_ = 0,
-                                        const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
-      : flags( flags_ )
-      , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
-      , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
-      , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
-      , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
+                                        const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
+      : layout::PipelineVertexInputStateCreateInfo( flags_, vertexBindingDescriptionCount_, pVertexBindingDescriptions_, vertexAttributeDescriptionCount_, pVertexAttributeDescriptions_ )
     {}
 
     PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineVertexInputStateCreateInfo( rhs )
+    {}
 
     PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs )
     {
@@ -30264,7 +34205,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineVertexInputStateCreateInfo & setFlags( PipelineVertexInputStateCreateFlags flags_ )
+    PipelineVertexInputStateCreateInfo & setFlags( vk::PipelineVertexInputStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -30276,7 +34217,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineVertexInputStateCreateInfo & setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ )
+    PipelineVertexInputStateCreateInfo & setPVertexBindingDescriptions( const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ )
     {
       pVertexBindingDescriptions = pVertexBindingDescriptions_;
       return *this;
@@ -30288,7 +34229,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineVertexInputStateCreateInfo & setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ )
+    PipelineVertexInputStateCreateInfo & setPVertexAttributeDescriptions( const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ )
     {
       pVertexAttributeDescriptions = pVertexAttributeDescriptions_;
       return *this;
@@ -30321,32 +34262,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineVertexInputStateCreateFlags flags;
-    uint32_t vertexBindingDescriptionCount;
-    const VertexInputBindingDescription* pVertexBindingDescriptions;
-    uint32_t vertexAttributeDescriptionCount;
-    const VertexInputAttributeDescription* pVertexAttributeDescriptions;
+    using layout::PipelineVertexInputStateCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineInputAssemblyStateCreateInfo
+    {
+    protected:
+      PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(),
+                                            vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList,
+                                            vk::Bool32 primitiveRestartEnable_ = 0 )
+        : flags( flags_ )
+        , topology( topology_ )
+        , primitiveRestartEnable( primitiveRestartEnable_ )
+      {}
+
+      PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineInputAssemblyStateCreateFlags flags;
+      vk::PrimitiveTopology topology;
+      vk::Bool32 primitiveRestartEnable;
+    };
+    static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineInputAssemblyStateCreateInfo
+  struct PipelineInputAssemblyStateCreateInfo : public layout::PipelineInputAssemblyStateCreateInfo
   {
-    PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(),
-                                          PrimitiveTopology topology_ = PrimitiveTopology::ePointList,
-                                          Bool32 primitiveRestartEnable_ = 0 )
-      : flags( flags_ )
-      , topology( topology_ )
-      , primitiveRestartEnable( primitiveRestartEnable_ )
+    PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(),
+                                          vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList,
+                                          vk::Bool32 primitiveRestartEnable_ = 0 )
+      : layout::PipelineInputAssemblyStateCreateInfo( flags_, topology_, primitiveRestartEnable_ )
     {}
 
     PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineInputAssemblyStateCreateInfo( rhs )
+    {}
 
     PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs )
     {
@@ -30360,19 +34325,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineInputAssemblyStateCreateInfo & setFlags( PipelineInputAssemblyStateCreateFlags flags_ )
+    PipelineInputAssemblyStateCreateInfo & setFlags( vk::PipelineInputAssemblyStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineInputAssemblyStateCreateInfo & setTopology( PrimitiveTopology topology_ )
+    PipelineInputAssemblyStateCreateInfo & setTopology( vk::PrimitiveTopology topology_ )
     {
       topology = topology_;
       return *this;
     }
 
-    PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ )
+    PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable( vk::Bool32 primitiveRestartEnable_ )
     {
       primitiveRestartEnable = primitiveRestartEnable_;
       return *this;
@@ -30403,28 +34368,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineInputAssemblyStateCreateFlags flags;
-    PrimitiveTopology topology;
-    Bool32 primitiveRestartEnable;
+    using layout::PipelineInputAssemblyStateCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineTessellationStateCreateInfo
+    {
+    protected:
+      PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(),
+                                           uint32_t patchControlPoints_ = 0 )
+        : flags( flags_ )
+        , patchControlPoints( patchControlPoints_ )
+      {}
+
+      PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
 
-  struct PipelineTessellationStateCreateInfo
+    public:
+      vk::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineTessellationStateCreateFlags flags;
+      uint32_t patchControlPoints;
+    };
+    static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineTessellationStateCreateInfo : public layout::PipelineTessellationStateCreateInfo
   {
-    PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(),
+    PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(),
                                          uint32_t patchControlPoints_ = 0 )
-      : flags( flags_ )
-      , patchControlPoints( patchControlPoints_ )
+      : layout::PipelineTessellationStateCreateInfo( flags_, patchControlPoints_ )
     {}
 
     PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineTessellationStateCreateInfo( rhs )
+    {}
 
     PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs )
     {
@@ -30438,7 +34427,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineTessellationStateCreateInfo & setFlags( PipelineTessellationStateCreateFlags flags_ )
+    PipelineTessellationStateCreateInfo & setFlags( vk::PipelineTessellationStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -30474,14 +34463,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineTessellationStateCreateFlags flags;
-    uint32_t patchControlPoints;
+    using layout::PipelineTessellationStateCreateInfo::sType;
   };
   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!" );
 
   struct Viewport
   {
@@ -30491,12 +34476,12 @@ namespace VULKAN_HPP_NAMESPACE
               float height_ = 0,
               float minDepth_ = 0,
               float maxDepth_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , width( width_ )
-      , height( height_ )
-      , minDepth( minDepth_ )
-      , maxDepth( maxDepth_ )
+        : x( x_ )
+        , y( y_ )
+        , width( width_ )
+        , height( height_ )
+        , minDepth( minDepth_ )
+        , maxDepth( maxDepth_ )
     {}
 
     Viewport( VkViewport const & rhs )
@@ -30571,6 +34556,7 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     float x;
     float y;
     float width;
@@ -30579,25 +34565,61 @@ namespace VULKAN_HPP_NAMESPACE
     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!" );
+
+  namespace layout
+  {
+    struct PipelineViewportStateCreateInfo
+    {
+    protected:
+      PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(),
+                                       uint32_t viewportCount_ = 0,
+                                       const vk::Viewport* pViewports_ = nullptr,
+                                       uint32_t scissorCount_ = 0,
+                                       const vk::Rect2D* pScissors_ = nullptr )
+        : flags( flags_ )
+        , viewportCount( viewportCount_ )
+        , pViewports( pViewports_ )
+        , scissorCount( scissorCount_ )
+        , pScissors( pScissors_ )
+      {}
 
-  struct PipelineViewportStateCreateInfo
+      PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineViewportStateCreateFlags flags;
+      uint32_t viewportCount;
+      const vk::Viewport* pViewports;
+      uint32_t scissorCount;
+      const vk::Rect2D* pScissors;
+    };
+    static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineViewportStateCreateInfo : public layout::PipelineViewportStateCreateInfo
   {
-    PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(),
+    PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(),
                                      uint32_t viewportCount_ = 0,
-                                     const Viewport* pViewports_ = nullptr,
+                                     const vk::Viewport* pViewports_ = nullptr,
                                      uint32_t scissorCount_ = 0,
-                                     const Rect2D* pScissors_ = nullptr )
-      : flags( flags_ )
-      , viewportCount( viewportCount_ )
-      , pViewports( pViewports_ )
-      , scissorCount( scissorCount_ )
-      , pScissors( pScissors_ )
+                                     const vk::Rect2D* pScissors_ = nullptr )
+      : layout::PipelineViewportStateCreateInfo( flags_, viewportCount_, pViewports_, scissorCount_, pScissors_ )
     {}
 
     PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineViewportStateCreateInfo( rhs )
+    {}
 
     PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs )
     {
@@ -30611,7 +34633,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportStateCreateInfo & setFlags( PipelineViewportStateCreateFlags flags_ )
+    PipelineViewportStateCreateInfo & setFlags( vk::PipelineViewportStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -30623,7 +34645,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportStateCreateInfo & setPViewports( const Viewport* pViewports_ )
+    PipelineViewportStateCreateInfo & setPViewports( const vk::Viewport* pViewports_ )
     {
       pViewports = pViewports_;
       return *this;
@@ -30635,7 +34657,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportStateCreateInfo & setPScissors( const Rect2D* pScissors_ )
+    PipelineViewportStateCreateInfo & setPScissors( const vk::Rect2D* pScissors_ )
     {
       pScissors = pScissors_;
       return *this;
@@ -30668,48 +34690,88 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineViewportStateCreateFlags flags;
-    uint32_t viewportCount;
-    const Viewport* pViewports;
-    uint32_t scissorCount;
-    const Rect2D* pScissors;
+    using layout::PipelineViewportStateCreateInfo::sType;
   };
   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!" );
 
-  struct PipelineRasterizationStateCreateInfo
+  namespace layout
   {
-    PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = PipelineRasterizationStateCreateFlags(),
-                                          Bool32 depthClampEnable_ = 0,
-                                          Bool32 rasterizerDiscardEnable_ = 0,
-                                          PolygonMode polygonMode_ = PolygonMode::eFill,
-                                          CullModeFlags cullMode_ = CullModeFlags(),
-                                          FrontFace frontFace_ = FrontFace::eCounterClockwise,
-                                          Bool32 depthBiasEnable_ = 0,
+    struct PipelineRasterizationStateCreateInfo
+    {
+    protected:
+      PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(),
+                                            vk::Bool32 depthClampEnable_ = 0,
+                                            vk::Bool32 rasterizerDiscardEnable_ = 0,
+                                            vk::PolygonMode polygonMode_ = vk::PolygonMode::eFill,
+                                            vk::CullModeFlags cullMode_ = vk::CullModeFlags(),
+                                            vk::FrontFace frontFace_ = vk::FrontFace::eCounterClockwise,
+                                            vk::Bool32 depthBiasEnable_ = 0,
+                                            float depthBiasConstantFactor_ = 0,
+                                            float depthBiasClamp_ = 0,
+                                            float depthBiasSlopeFactor_ = 0,
+                                            float lineWidth_ = 0 )
+        : flags( flags_ )
+        , depthClampEnable( depthClampEnable_ )
+        , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
+        , polygonMode( polygonMode_ )
+        , cullMode( cullMode_ )
+        , frontFace( frontFace_ )
+        , depthBiasEnable( depthBiasEnable_ )
+        , depthBiasConstantFactor( depthBiasConstantFactor_ )
+        , depthBiasClamp( depthBiasClamp_ )
+        , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
+        , lineWidth( lineWidth_ )
+      {}
+
+      PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineRasterizationStateCreateFlags flags;
+      vk::Bool32 depthClampEnable;
+      vk::Bool32 rasterizerDiscardEnable;
+      vk::PolygonMode polygonMode;
+      vk::CullModeFlags cullMode;
+      vk::FrontFace frontFace;
+      vk::Bool32 depthBiasEnable;
+      float depthBiasConstantFactor;
+      float depthBiasClamp;
+      float depthBiasSlopeFactor;
+      float lineWidth;
+    };
+    static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineRasterizationStateCreateInfo : public layout::PipelineRasterizationStateCreateInfo
+  {
+    PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(),
+                                          vk::Bool32 depthClampEnable_ = 0,
+                                          vk::Bool32 rasterizerDiscardEnable_ = 0,
+                                          vk::PolygonMode polygonMode_ = vk::PolygonMode::eFill,
+                                          vk::CullModeFlags cullMode_ = vk::CullModeFlags(),
+                                          vk::FrontFace frontFace_ = vk::FrontFace::eCounterClockwise,
+                                          vk::Bool32 depthBiasEnable_ = 0,
                                           float depthBiasConstantFactor_ = 0,
                                           float depthBiasClamp_ = 0,
                                           float depthBiasSlopeFactor_ = 0,
                                           float lineWidth_ = 0 )
-      : flags( flags_ )
-      , depthClampEnable( depthClampEnable_ )
-      , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
-      , polygonMode( polygonMode_ )
-      , cullMode( cullMode_ )
-      , frontFace( frontFace_ )
-      , depthBiasEnable( depthBiasEnable_ )
-      , depthBiasConstantFactor( depthBiasConstantFactor_ )
-      , depthBiasClamp( depthBiasClamp_ )
-      , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
-      , lineWidth( lineWidth_ )
+      : layout::PipelineRasterizationStateCreateInfo( flags_, depthClampEnable_, rasterizerDiscardEnable_, polygonMode_, cullMode_, frontFace_, depthBiasEnable_, depthBiasConstantFactor_, depthBiasClamp_, depthBiasSlopeFactor_, lineWidth_ )
     {}
 
     PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineRasterizationStateCreateInfo( rhs )
+    {}
 
     PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs )
     {
@@ -30723,43 +34785,43 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo & setFlags( PipelineRasterizationStateCreateFlags flags_ )
+    PipelineRasterizationStateCreateInfo & setFlags( vk::PipelineRasterizationStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo & setDepthClampEnable( Bool32 depthClampEnable_ )
+    PipelineRasterizationStateCreateInfo & setDepthClampEnable( vk::Bool32 depthClampEnable_ )
     {
       depthClampEnable = depthClampEnable_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ )
+    PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable( vk::Bool32 rasterizerDiscardEnable_ )
     {
       rasterizerDiscardEnable = rasterizerDiscardEnable_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo & setPolygonMode( PolygonMode polygonMode_ )
+    PipelineRasterizationStateCreateInfo & setPolygonMode( vk::PolygonMode polygonMode_ )
     {
       polygonMode = polygonMode_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo & setCullMode( CullModeFlags cullMode_ )
+    PipelineRasterizationStateCreateInfo & setCullMode( vk::CullModeFlags cullMode_ )
     {
       cullMode = cullMode_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo & setFrontFace( FrontFace frontFace_ )
+    PipelineRasterizationStateCreateInfo & setFrontFace( vk::FrontFace frontFace_ )
     {
       frontFace = frontFace_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo & setDepthBiasEnable( Bool32 depthBiasEnable_ )
+    PipelineRasterizationStateCreateInfo & setDepthBiasEnable( vk::Bool32 depthBiasEnable_ )
     {
       depthBiasEnable = depthBiasEnable_;
       return *this;
@@ -30822,46 +34884,72 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineRasterizationStateCreateFlags flags;
-    Bool32 depthClampEnable;
-    Bool32 rasterizerDiscardEnable;
-    PolygonMode polygonMode;
-    CullModeFlags cullMode;
-    FrontFace frontFace;
-    Bool32 depthBiasEnable;
-    float depthBiasConstantFactor;
-    float depthBiasClamp;
-    float depthBiasSlopeFactor;
-    float lineWidth;
+    using layout::PipelineRasterizationStateCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineMultisampleStateCreateInfo
+    {
+    protected:
+      PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(),
+                                          vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1,
+                                          vk::Bool32 sampleShadingEnable_ = 0,
+                                          float minSampleShading_ = 0,
+                                          const vk::SampleMask* pSampleMask_ = nullptr,
+                                          vk::Bool32 alphaToCoverageEnable_ = 0,
+                                          vk::Bool32 alphaToOneEnable_ = 0 )
+        : flags( flags_ )
+        , rasterizationSamples( rasterizationSamples_ )
+        , sampleShadingEnable( sampleShadingEnable_ )
+        , minSampleShading( minSampleShading_ )
+        , pSampleMask( pSampleMask_ )
+        , alphaToCoverageEnable( alphaToCoverageEnable_ )
+        , alphaToOneEnable( alphaToOneEnable_ )
+      {}
+
+      PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineMultisampleStateCreateFlags flags;
+      vk::SampleCountFlagBits rasterizationSamples;
+      vk::Bool32 sampleShadingEnable;
+      float minSampleShading;
+      const vk::SampleMask* pSampleMask;
+      vk::Bool32 alphaToCoverageEnable;
+      vk::Bool32 alphaToOneEnable;
+    };
+    static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineMultisampleStateCreateInfo
+  struct PipelineMultisampleStateCreateInfo : public layout::PipelineMultisampleStateCreateInfo
   {
-    PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(),
-                                        SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1,
-                                        Bool32 sampleShadingEnable_ = 0,
+    PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(),
+                                        vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1,
+                                        vk::Bool32 sampleShadingEnable_ = 0,
                                         float minSampleShading_ = 0,
-                                        const SampleMask* pSampleMask_ = nullptr,
-                                        Bool32 alphaToCoverageEnable_ = 0,
-                                        Bool32 alphaToOneEnable_ = 0 )
-      : flags( flags_ )
-      , rasterizationSamples( rasterizationSamples_ )
-      , sampleShadingEnable( sampleShadingEnable_ )
-      , minSampleShading( minSampleShading_ )
-      , pSampleMask( pSampleMask_ )
-      , alphaToCoverageEnable( alphaToCoverageEnable_ )
-      , alphaToOneEnable( alphaToOneEnable_ )
+                                        const vk::SampleMask* pSampleMask_ = nullptr,
+                                        vk::Bool32 alphaToCoverageEnable_ = 0,
+                                        vk::Bool32 alphaToOneEnable_ = 0 )
+      : layout::PipelineMultisampleStateCreateInfo( flags_, rasterizationSamples_, sampleShadingEnable_, minSampleShading_, pSampleMask_, alphaToCoverageEnable_, alphaToOneEnable_ )
     {}
 
     PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineMultisampleStateCreateInfo( rhs )
+    {}
 
     PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
     {
@@ -30875,19 +34963,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineMultisampleStateCreateInfo & setFlags( PipelineMultisampleStateCreateFlags flags_ )
+    PipelineMultisampleStateCreateInfo & setFlags( vk::PipelineMultisampleStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineMultisampleStateCreateInfo & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
+    PipelineMultisampleStateCreateInfo & setRasterizationSamples( vk::SampleCountFlagBits rasterizationSamples_ )
     {
       rasterizationSamples = rasterizationSamples_;
       return *this;
     }
 
-    PipelineMultisampleStateCreateInfo & setSampleShadingEnable( Bool32 sampleShadingEnable_ )
+    PipelineMultisampleStateCreateInfo & setSampleShadingEnable( vk::Bool32 sampleShadingEnable_ )
     {
       sampleShadingEnable = sampleShadingEnable_;
       return *this;
@@ -30899,19 +34987,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineMultisampleStateCreateInfo & setPSampleMask( const SampleMask* pSampleMask_ )
+    PipelineMultisampleStateCreateInfo & setPSampleMask( const vk::SampleMask* pSampleMask_ )
     {
       pSampleMask = pSampleMask_;
       return *this;
     }
 
-    PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
+    PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable( vk::Bool32 alphaToCoverageEnable_ )
     {
       alphaToCoverageEnable = alphaToCoverageEnable_;
       return *this;
     }
 
-    PipelineMultisampleStateCreateInfo & setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
+    PipelineMultisampleStateCreateInfo & setAlphaToOneEnable( vk::Bool32 alphaToOneEnable_ )
     {
       alphaToOneEnable = alphaToOneEnable_;
       return *this;
@@ -30946,36 +35034,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineMultisampleStateCreateFlags flags;
-    SampleCountFlagBits rasterizationSamples;
-    Bool32 sampleShadingEnable;
-    float minSampleShading;
-    const SampleMask* pSampleMask;
-    Bool32 alphaToCoverageEnable;
-    Bool32 alphaToOneEnable;
+    using layout::PipelineMultisampleStateCreateInfo::sType;
   };
   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!" );
 
   struct StencilOpState
   {
-    StencilOpState( StencilOp failOp_ = StencilOp::eKeep,
-                    StencilOp passOp_ = StencilOp::eKeep,
-                    StencilOp depthFailOp_ = StencilOp::eKeep,
-                    CompareOp compareOp_ = CompareOp::eNever,
+    StencilOpState( vk::StencilOp failOp_ = vk::StencilOp::eKeep,
+                    vk::StencilOp passOp_ = vk::StencilOp::eKeep,
+                    vk::StencilOp depthFailOp_ = vk::StencilOp::eKeep,
+                    vk::CompareOp compareOp_ = vk::CompareOp::eNever,
                     uint32_t compareMask_ = 0,
                     uint32_t writeMask_ = 0,
                     uint32_t reference_ = 0 )
-      : failOp( failOp_ )
-      , passOp( passOp_ )
-      , depthFailOp( depthFailOp_ )
-      , compareOp( compareOp_ )
-      , compareMask( compareMask_ )
-      , writeMask( writeMask_ )
-      , reference( reference_ )
+        : failOp( failOp_ )
+        , passOp( passOp_ )
+        , depthFailOp( depthFailOp_ )
+        , compareOp( compareOp_ )
+        , compareMask( compareMask_ )
+        , writeMask( writeMask_ )
+        , reference( reference_ )
     {}
 
     StencilOpState( VkStencilOpState const & rhs )
@@ -30989,25 +35068,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    StencilOpState & setFailOp( StencilOp failOp_ )
+    StencilOpState & setFailOp( vk::StencilOp failOp_ )
     {
       failOp = failOp_;
       return *this;
     }
 
-    StencilOpState & setPassOp( StencilOp passOp_ )
+    StencilOpState & setPassOp( vk::StencilOp passOp_ )
     {
       passOp = passOp_;
       return *this;
     }
 
-    StencilOpState & setDepthFailOp( StencilOp depthFailOp_ )
+    StencilOpState & setDepthFailOp( vk::StencilOp depthFailOp_ )
     {
       depthFailOp = depthFailOp_;
       return *this;
     }
 
-    StencilOpState & setCompareOp( CompareOp compareOp_ )
+    StencilOpState & setCompareOp( vk::CompareOp compareOp_ )
     {
       compareOp = compareOp_;
       return *this;
@@ -31057,44 +35136,91 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    StencilOp failOp;
-    StencilOp passOp;
-    StencilOp depthFailOp;
-    CompareOp compareOp;
+  public:
+    vk::StencilOp failOp;
+    vk::StencilOp passOp;
+    vk::StencilOp depthFailOp;
+    vk::CompareOp compareOp;
     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!" );
+
+  namespace layout
+  {
+    struct PipelineDepthStencilStateCreateInfo
+    {
+    protected:
+      PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(),
+                                           vk::Bool32 depthTestEnable_ = 0,
+                                           vk::Bool32 depthWriteEnable_ = 0,
+                                           vk::CompareOp depthCompareOp_ = vk::CompareOp::eNever,
+                                           vk::Bool32 depthBoundsTestEnable_ = 0,
+                                           vk::Bool32 stencilTestEnable_ = 0,
+                                           vk::StencilOpState front_ = vk::StencilOpState(),
+                                           vk::StencilOpState back_ = vk::StencilOpState(),
+                                           float minDepthBounds_ = 0,
+                                           float maxDepthBounds_ = 0 )
+        : flags( flags_ )
+        , depthTestEnable( depthTestEnable_ )
+        , depthWriteEnable( depthWriteEnable_ )
+        , depthCompareOp( depthCompareOp_ )
+        , depthBoundsTestEnable( depthBoundsTestEnable_ )
+        , stencilTestEnable( stencilTestEnable_ )
+        , front( front_ )
+        , back( back_ )
+        , minDepthBounds( minDepthBounds_ )
+        , maxDepthBounds( maxDepthBounds_ )
+      {}
+
+      PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this) = rhs;
+      }
 
-  struct PipelineDepthStencilStateCreateInfo
+      PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineDepthStencilStateCreateFlags flags;
+      vk::Bool32 depthTestEnable;
+      vk::Bool32 depthWriteEnable;
+      vk::CompareOp depthCompareOp;
+      vk::Bool32 depthBoundsTestEnable;
+      vk::Bool32 stencilTestEnable;
+      vk::StencilOpState front;
+      vk::StencilOpState back;
+      float minDepthBounds;
+      float maxDepthBounds;
+    };
+    static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineDepthStencilStateCreateInfo : public layout::PipelineDepthStencilStateCreateInfo
   {
-    PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(),
-                                         Bool32 depthTestEnable_ = 0,
-                                         Bool32 depthWriteEnable_ = 0,
-                                         CompareOp depthCompareOp_ = CompareOp::eNever,
-                                         Bool32 depthBoundsTestEnable_ = 0,
-                                         Bool32 stencilTestEnable_ = 0,
-                                         StencilOpState front_ = StencilOpState(),
-                                         StencilOpState back_ = StencilOpState(),
+    PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(),
+                                         vk::Bool32 depthTestEnable_ = 0,
+                                         vk::Bool32 depthWriteEnable_ = 0,
+                                         vk::CompareOp depthCompareOp_ = vk::CompareOp::eNever,
+                                         vk::Bool32 depthBoundsTestEnable_ = 0,
+                                         vk::Bool32 stencilTestEnable_ = 0,
+                                         vk::StencilOpState front_ = vk::StencilOpState(),
+                                         vk::StencilOpState back_ = vk::StencilOpState(),
                                          float minDepthBounds_ = 0,
                                          float maxDepthBounds_ = 0 )
-      : flags( flags_ )
-      , depthTestEnable( depthTestEnable_ )
-      , depthWriteEnable( depthWriteEnable_ )
-      , depthCompareOp( depthCompareOp_ )
-      , depthBoundsTestEnable( depthBoundsTestEnable_ )
-      , stencilTestEnable( stencilTestEnable_ )
-      , front( front_ )
-      , back( back_ )
-      , minDepthBounds( minDepthBounds_ )
-      , maxDepthBounds( maxDepthBounds_ )
+      : layout::PipelineDepthStencilStateCreateInfo( flags_, depthTestEnable_, depthWriteEnable_, depthCompareOp_, depthBoundsTestEnable_, stencilTestEnable_, front_, back_, minDepthBounds_, maxDepthBounds_ )
     {}
 
     PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineDepthStencilStateCreateInfo( rhs )
+    {}
 
     PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs )
     {
@@ -31108,49 +35234,49 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setFlags( PipelineDepthStencilStateCreateFlags flags_ )
+    PipelineDepthStencilStateCreateInfo & setFlags( vk::PipelineDepthStencilStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setDepthTestEnable( Bool32 depthTestEnable_ )
+    PipelineDepthStencilStateCreateInfo & setDepthTestEnable( vk::Bool32 depthTestEnable_ )
     {
       depthTestEnable = depthTestEnable_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setDepthWriteEnable( Bool32 depthWriteEnable_ )
+    PipelineDepthStencilStateCreateInfo & setDepthWriteEnable( vk::Bool32 depthWriteEnable_ )
     {
       depthWriteEnable = depthWriteEnable_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setDepthCompareOp( CompareOp depthCompareOp_ )
+    PipelineDepthStencilStateCreateInfo & setDepthCompareOp( vk::CompareOp depthCompareOp_ )
     {
       depthCompareOp = depthCompareOp_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ )
+    PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable( vk::Bool32 depthBoundsTestEnable_ )
     {
       depthBoundsTestEnable = depthBoundsTestEnable_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setStencilTestEnable( Bool32 stencilTestEnable_ )
+    PipelineDepthStencilStateCreateInfo & setStencilTestEnable( vk::Bool32 stencilTestEnable_ )
     {
       stencilTestEnable = stencilTestEnable_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setFront( StencilOpState front_ )
+    PipelineDepthStencilStateCreateInfo & setFront( vk::StencilOpState front_ )
     {
       front = front_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo & setBack( StencilOpState back_ )
+    PipelineDepthStencilStateCreateInfo & setBack( vk::StencilOpState back_ )
     {
       back = back_;
       return *this;
@@ -31200,41 +35326,29 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineDepthStencilStateCreateFlags flags;
-    Bool32 depthTestEnable;
-    Bool32 depthWriteEnable;
-    CompareOp depthCompareOp;
-    Bool32 depthBoundsTestEnable;
-    Bool32 stencilTestEnable;
-    StencilOpState front;
-    StencilOpState back;
-    float minDepthBounds;
-    float maxDepthBounds;
+    using layout::PipelineDepthStencilStateCreateInfo::sType;
   };
   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!" );
 
   struct PipelineColorBlendAttachmentState
   {
-    PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0,
-                                       BlendFactor srcColorBlendFactor_ = BlendFactor::eZero,
-                                       BlendFactor dstColorBlendFactor_ = BlendFactor::eZero,
-                                       BlendOp colorBlendOp_ = BlendOp::eAdd,
-                                       BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero,
-                                       BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero,
-                                       BlendOp alphaBlendOp_ = BlendOp::eAdd,
-                                       ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
-      : blendEnable( blendEnable_ )
-      , srcColorBlendFactor( srcColorBlendFactor_ )
-      , dstColorBlendFactor( dstColorBlendFactor_ )
-      , colorBlendOp( colorBlendOp_ )
-      , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
-      , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
-      , alphaBlendOp( alphaBlendOp_ )
-      , colorWriteMask( colorWriteMask_ )
+    PipelineColorBlendAttachmentState( vk::Bool32 blendEnable_ = 0,
+                                       vk::BlendFactor srcColorBlendFactor_ = vk::BlendFactor::eZero,
+                                       vk::BlendFactor dstColorBlendFactor_ = vk::BlendFactor::eZero,
+                                       vk::BlendOp colorBlendOp_ = vk::BlendOp::eAdd,
+                                       vk::BlendFactor srcAlphaBlendFactor_ = vk::BlendFactor::eZero,
+                                       vk::BlendFactor dstAlphaBlendFactor_ = vk::BlendFactor::eZero,
+                                       vk::BlendOp alphaBlendOp_ = vk::BlendOp::eAdd,
+                                       vk::ColorComponentFlags colorWriteMask_ = vk::ColorComponentFlags() )
+        : blendEnable( blendEnable_ )
+        , srcColorBlendFactor( srcColorBlendFactor_ )
+        , dstColorBlendFactor( dstColorBlendFactor_ )
+        , colorBlendOp( colorBlendOp_ )
+        , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
+        , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
+        , alphaBlendOp( alphaBlendOp_ )
+        , colorWriteMask( colorWriteMask_ )
     {}
 
     PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
@@ -31248,49 +35362,49 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineColorBlendAttachmentState & setBlendEnable( Bool32 blendEnable_ )
+    PipelineColorBlendAttachmentState & setBlendEnable( vk::Bool32 blendEnable_ )
     {
       blendEnable = blendEnable_;
       return *this;
     }
 
-    PipelineColorBlendAttachmentState & setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
+    PipelineColorBlendAttachmentState & setSrcColorBlendFactor( vk::BlendFactor srcColorBlendFactor_ )
     {
       srcColorBlendFactor = srcColorBlendFactor_;
       return *this;
     }
 
-    PipelineColorBlendAttachmentState & setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
+    PipelineColorBlendAttachmentState & setDstColorBlendFactor( vk::BlendFactor dstColorBlendFactor_ )
     {
       dstColorBlendFactor = dstColorBlendFactor_;
       return *this;
     }
 
-    PipelineColorBlendAttachmentState & setColorBlendOp( BlendOp colorBlendOp_ )
+    PipelineColorBlendAttachmentState & setColorBlendOp( vk::BlendOp colorBlendOp_ )
     {
       colorBlendOp = colorBlendOp_;
       return *this;
     }
 
-    PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
+    PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor( vk::BlendFactor srcAlphaBlendFactor_ )
     {
       srcAlphaBlendFactor = srcAlphaBlendFactor_;
       return *this;
     }
 
-    PipelineColorBlendAttachmentState & setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
+    PipelineColorBlendAttachmentState & setDstAlphaBlendFactor( vk::BlendFactor dstAlphaBlendFactor_ )
     {
       dstAlphaBlendFactor = dstAlphaBlendFactor_;
       return *this;
     }
 
-    PipelineColorBlendAttachmentState & setAlphaBlendOp( BlendOp alphaBlendOp_ )
+    PipelineColorBlendAttachmentState & setAlphaBlendOp( vk::BlendOp alphaBlendOp_ )
     {
       alphaBlendOp = alphaBlendOp_;
       return *this;
     }
 
-    PipelineColorBlendAttachmentState & setColorWriteMask( ColorComponentFlags colorWriteMask_ )
+    PipelineColorBlendAttachmentState & setColorWriteMask( vk::ColorComponentFlags colorWriteMask_ )
     {
       colorWriteMask = colorWriteMask_;
       return *this;
@@ -31323,38 +35437,78 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Bool32 blendEnable;
-    BlendFactor srcColorBlendFactor;
-    BlendFactor dstColorBlendFactor;
-    BlendOp colorBlendOp;
-    BlendFactor srcAlphaBlendFactor;
-    BlendFactor dstAlphaBlendFactor;
-    BlendOp alphaBlendOp;
-    ColorComponentFlags colorWriteMask;
+  public:
+    vk::Bool32 blendEnable;
+    vk::BlendFactor srcColorBlendFactor;
+    vk::BlendFactor dstColorBlendFactor;
+    vk::BlendOp colorBlendOp;
+    vk::BlendFactor srcAlphaBlendFactor;
+    vk::BlendFactor dstAlphaBlendFactor;
+    vk::BlendOp alphaBlendOp;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct PipelineColorBlendStateCreateInfo
+    {
+    protected:
+      PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(),
+                                         vk::Bool32 logicOpEnable_ = 0,
+                                         vk::LogicOp logicOp_ = vk::LogicOp::eClear,
+                                         uint32_t attachmentCount_ = 0,
+                                         const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
+                                         std::array<float,4> const& blendConstants_ = { { 0 } } )
+        : flags( flags_ )
+        , logicOpEnable( logicOpEnable_ )
+        , logicOp( logicOp_ )
+        , attachmentCount( attachmentCount_ )
+        , pAttachments( pAttachments_ )
+      {
+        memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
+      
+      }
+
+      PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
 
-  struct PipelineColorBlendStateCreateInfo
+    public:
+      vk::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineColorBlendStateCreateFlags flags;
+      vk::Bool32 logicOpEnable;
+      vk::LogicOp logicOp;
+      uint32_t attachmentCount;
+      const vk::PipelineColorBlendAttachmentState* pAttachments;
+      float blendConstants[4];
+    };
+    static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineColorBlendStateCreateInfo : public layout::PipelineColorBlendStateCreateInfo
   {
-    PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(),
-                                       Bool32 logicOpEnable_ = 0,
-                                       LogicOp logicOp_ = LogicOp::eClear,
+    PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(),
+                                       vk::Bool32 logicOpEnable_ = 0,
+                                       vk::LogicOp logicOp_ = vk::LogicOp::eClear,
                                        uint32_t attachmentCount_ = 0,
-                                       const PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
+                                       const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
                                        std::array<float,4> const& blendConstants_ = { { 0 } } )
-      : flags( flags_ )
-      , logicOpEnable( logicOpEnable_ )
-      , logicOp( logicOp_ )
-      , attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
-    {
-      memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
-    }
+      : layout::PipelineColorBlendStateCreateInfo( flags_, logicOpEnable_, logicOp_, attachmentCount_, pAttachments_, blendConstants_ )
+    {}
 
     PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineColorBlendStateCreateInfo( rhs )
+    {}
 
     PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
     {
@@ -31368,19 +35522,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineColorBlendStateCreateInfo & setFlags( PipelineColorBlendStateCreateFlags flags_ )
+    PipelineColorBlendStateCreateInfo & setFlags( vk::PipelineColorBlendStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineColorBlendStateCreateInfo & setLogicOpEnable( Bool32 logicOpEnable_ )
+    PipelineColorBlendStateCreateInfo & setLogicOpEnable( vk::Bool32 logicOpEnable_ )
     {
       logicOpEnable = logicOpEnable_;
       return *this;
     }
 
-    PipelineColorBlendStateCreateInfo & setLogicOp( LogicOp logicOp_ )
+    PipelineColorBlendStateCreateInfo & setLogicOp( vk::LogicOp logicOp_ )
     {
       logicOp = logicOp_;
       return *this;
@@ -31392,7 +35546,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineColorBlendStateCreateInfo & setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
+    PipelineColorBlendStateCreateInfo & setPAttachments( const vk::PipelineColorBlendAttachmentState* pAttachments_ )
     {
       pAttachments = pAttachments_;
       return *this;
@@ -31432,33 +35586,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineColorBlendStateCreateFlags flags;
-    Bool32 logicOpEnable;
-    LogicOp logicOp;
-    uint32_t attachmentCount;
-    const PipelineColorBlendAttachmentState* pAttachments;
-    float blendConstants[4];
+    using layout::PipelineColorBlendStateCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineDynamicStateCreateInfo
+    {
+    protected:
+      PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(),
+                                      uint32_t dynamicStateCount_ = 0,
+                                      const vk::DynamicState* pDynamicStates_ = nullptr )
+        : flags( flags_ )
+        , dynamicStateCount( dynamicStateCount_ )
+        , pDynamicStates( pDynamicStates_ )
+      {}
+
+      PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineDynamicStateCreateFlags flags;
+      uint32_t dynamicStateCount;
+      const vk::DynamicState* pDynamicStates;
+    };
+    static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineDynamicStateCreateInfo
+  struct PipelineDynamicStateCreateInfo : public layout::PipelineDynamicStateCreateInfo
   {
-    PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(),
+    PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(),
                                     uint32_t dynamicStateCount_ = 0,
-                                    const DynamicState* pDynamicStates_ = nullptr )
-      : flags( flags_ )
-      , dynamicStateCount( dynamicStateCount_ )
-      , pDynamicStates( pDynamicStates_ )
+                                    const vk::DynamicState* pDynamicStates_ = nullptr )
+      : layout::PipelineDynamicStateCreateInfo( flags_, dynamicStateCount_, pDynamicStates_ )
     {}
 
     PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineDynamicStateCreateInfo( rhs )
+    {}
 
     PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
     {
@@ -31472,7 +35649,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineDynamicStateCreateInfo & setFlags( PipelineDynamicStateCreateFlags flags_ )
+    PipelineDynamicStateCreateInfo & setFlags( vk::PipelineDynamicStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -31484,7 +35661,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineDynamicStateCreateInfo & setPDynamicStates( const DynamicState* pDynamicStates_ )
+    PipelineDynamicStateCreateInfo & setPDynamicStates( const vk::DynamicState* pDynamicStates_ )
     {
       pDynamicStates = pDynamicStates_;
       return *this;
@@ -31515,58 +35692,112 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineDynamicStateCreateFlags flags;
-    uint32_t dynamicStateCount;
-    const DynamicState* pDynamicStates;
+    using layout::PipelineDynamicStateCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct GraphicsPipelineCreateInfo
+    {
+    protected:
+      GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+                                  uint32_t stageCount_ = 0,
+                                  const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr,
+                                  const vk::PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr,
+                                  const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr,
+                                  const vk::PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr,
+                                  const vk::PipelineViewportStateCreateInfo* pViewportState_ = nullptr,
+                                  const vk::PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr,
+                                  const vk::PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr,
+                                  const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr,
+                                  const vk::PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr,
+                                  const vk::PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr,
+                                  vk::PipelineLayout layout_ = vk::PipelineLayout(),
+                                  vk::RenderPass renderPass_ = vk::RenderPass(),
+                                  uint32_t subpass_ = 0,
+                                  vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+                                  int32_t basePipelineIndex_ = 0 )
+        : flags( flags_ )
+        , stageCount( stageCount_ )
+        , pStages( pStages_ )
+        , pVertexInputState( pVertexInputState_ )
+        , pInputAssemblyState( pInputAssemblyState_ )
+        , pTessellationState( pTessellationState_ )
+        , pViewportState( pViewportState_ )
+        , pRasterizationState( pRasterizationState_ )
+        , pMultisampleState( pMultisampleState_ )
+        , pDepthStencilState( pDepthStencilState_ )
+        , pColorBlendState( pColorBlendState_ )
+        , pDynamicState( pDynamicState_ )
+        , layout( layout_ )
+        , renderPass( renderPass_ )
+        , subpass( subpass_ )
+        , basePipelineHandle( basePipelineHandle_ )
+        , basePipelineIndex( basePipelineIndex_ )
+      {}
+
+      GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this) = rhs;
+      }
 
-  struct GraphicsPipelineCreateInfo
+      GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineCreateFlags flags;
+      uint32_t stageCount;
+      const vk::PipelineShaderStageCreateInfo* pStages;
+      const vk::PipelineVertexInputStateCreateInfo* pVertexInputState;
+      const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+      const vk::PipelineTessellationStateCreateInfo* pTessellationState;
+      const vk::PipelineViewportStateCreateInfo* pViewportState;
+      const vk::PipelineRasterizationStateCreateInfo* pRasterizationState;
+      const vk::PipelineMultisampleStateCreateInfo* pMultisampleState;
+      const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState;
+      const vk::PipelineColorBlendStateCreateInfo* pColorBlendState;
+      const vk::PipelineDynamicStateCreateInfo* pDynamicState;
+      vk::PipelineLayout layout;
+      vk::RenderPass renderPass;
+      uint32_t subpass;
+      vk::Pipeline basePipelineHandle;
+      int32_t basePipelineIndex;
+    };
+    static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct GraphicsPipelineCreateInfo : public layout::GraphicsPipelineCreateInfo
   {
-    GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
+    GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
                                 uint32_t stageCount_ = 0,
-                                const PipelineShaderStageCreateInfo* pStages_ = nullptr,
-                                const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr,
-                                const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr,
-                                const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr,
-                                const PipelineViewportStateCreateInfo* pViewportState_ = nullptr,
-                                const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr,
-                                const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr,
-                                const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr,
-                                const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr,
-                                const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr,
-                                PipelineLayout layout_ = PipelineLayout(),
-                                RenderPass renderPass_ = RenderPass(),
+                                const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr,
+                                const vk::PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr,
+                                const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr,
+                                const vk::PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr,
+                                const vk::PipelineViewportStateCreateInfo* pViewportState_ = nullptr,
+                                const vk::PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr,
+                                const vk::PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr,
+                                const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr,
+                                const vk::PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr,
+                                const vk::PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr,
+                                vk::PipelineLayout layout_ = vk::PipelineLayout(),
+                                vk::RenderPass renderPass_ = vk::RenderPass(),
                                 uint32_t subpass_ = 0,
-                                Pipeline basePipelineHandle_ = Pipeline(),
+                                vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
                                 int32_t basePipelineIndex_ = 0 )
-      : flags( flags_ )
-      , stageCount( stageCount_ )
-      , pStages( pStages_ )
-      , pVertexInputState( pVertexInputState_ )
-      , pInputAssemblyState( pInputAssemblyState_ )
-      , pTessellationState( pTessellationState_ )
-      , pViewportState( pViewportState_ )
-      , pRasterizationState( pRasterizationState_ )
-      , pMultisampleState( pMultisampleState_ )
-      , pDepthStencilState( pDepthStencilState_ )
-      , pColorBlendState( pColorBlendState_ )
-      , pDynamicState( pDynamicState_ )
-      , layout( layout_ )
-      , renderPass( renderPass_ )
-      , subpass( subpass_ )
-      , basePipelineHandle( basePipelineHandle_ )
-      , basePipelineIndex( basePipelineIndex_ )
+      : layout::GraphicsPipelineCreateInfo( flags_, stageCount_, pStages_, pVertexInputState_, pInputAssemblyState_, pTessellationState_, pViewportState_, pRasterizationState_, pMultisampleState_, pDepthStencilState_, pColorBlendState_, pDynamicState_, layout_, renderPass_, subpass_, basePipelineHandle_, basePipelineIndex_ )
     {}
 
     GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this) = rhs;
-    }
+      : layout::GraphicsPipelineCreateInfo( rhs )
+    {}
 
     GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
     {
@@ -31580,7 +35811,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setFlags( PipelineCreateFlags flags_ )
+    GraphicsPipelineCreateInfo & setFlags( vk::PipelineCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -31592,73 +35823,73 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+    GraphicsPipelineCreateInfo & setPStages( const vk::PipelineShaderStageCreateInfo* pStages_ )
     {
       pStages = pStages_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
+    GraphicsPipelineCreateInfo & setPVertexInputState( const vk::PipelineVertexInputStateCreateInfo* pVertexInputState_ )
     {
       pVertexInputState = pVertexInputState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
+    GraphicsPipelineCreateInfo & setPInputAssemblyState( const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
     {
       pInputAssemblyState = pInputAssemblyState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
+    GraphicsPipelineCreateInfo & setPTessellationState( const vk::PipelineTessellationStateCreateInfo* pTessellationState_ )
     {
       pTessellationState = pTessellationState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
+    GraphicsPipelineCreateInfo & setPViewportState( const vk::PipelineViewportStateCreateInfo* pViewportState_ )
     {
       pViewportState = pViewportState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
+    GraphicsPipelineCreateInfo & setPRasterizationState( const vk::PipelineRasterizationStateCreateInfo* pRasterizationState_ )
     {
       pRasterizationState = pRasterizationState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
+    GraphicsPipelineCreateInfo & setPMultisampleState( const vk::PipelineMultisampleStateCreateInfo* pMultisampleState_ )
     {
       pMultisampleState = pMultisampleState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
+    GraphicsPipelineCreateInfo & setPDepthStencilState( const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
     {
       pDepthStencilState = pDepthStencilState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
+    GraphicsPipelineCreateInfo & setPColorBlendState( const vk::PipelineColorBlendStateCreateInfo* pColorBlendState_ )
     {
       pColorBlendState = pColorBlendState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
+    GraphicsPipelineCreateInfo & setPDynamicState( const vk::PipelineDynamicStateCreateInfo* pDynamicState_ )
     {
       pDynamicState = pDynamicState_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setLayout( PipelineLayout layout_ )
+    GraphicsPipelineCreateInfo & setLayout( vk::PipelineLayout layout_ )
     {
       layout = layout_;
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setRenderPass( RenderPass renderPass_ )
+    GraphicsPipelineCreateInfo & setRenderPass( vk::RenderPass renderPass_ )
     {
       renderPass = renderPass_;
       return *this;
@@ -31670,7 +35901,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    GraphicsPipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+    GraphicsPipelineCreateInfo & setBasePipelineHandle( vk::Pipeline basePipelineHandle_ )
     {
       basePipelineHandle = basePipelineHandle_;
       return *this;
@@ -31721,36 +35952,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCreateFlags flags;
-    uint32_t stageCount;
-    const PipelineShaderStageCreateInfo* pStages;
-    const PipelineVertexInputStateCreateInfo* pVertexInputState;
-    const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
-    const PipelineTessellationStateCreateInfo* pTessellationState;
-    const PipelineViewportStateCreateInfo* pViewportState;
-    const PipelineRasterizationStateCreateInfo* pRasterizationState;
-    const PipelineMultisampleStateCreateInfo* pMultisampleState;
-    const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
-    const PipelineColorBlendStateCreateInfo* pColorBlendState;
-    const PipelineDynamicStateCreateInfo* pDynamicState;
-    PipelineLayout layout;
-    RenderPass renderPass;
-    uint32_t subpass;
-    Pipeline basePipelineHandle;
-    int32_t basePipelineIndex;
+    using layout::GraphicsPipelineCreateInfo::sType;
   };
   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!" );
 
   struct XYColorEXT
   {
     XYColorEXT( float x_ = 0,
                 float y_ = 0 )
-      : x( x_ )
-      , y( y_ )
+        : x( x_ )
+        , y( y_ )
     {}
 
     XYColorEXT( VkXYColorEXT const & rhs )
@@ -31797,35 +36009,78 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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!" );
+
+  namespace layout
+  {
+    struct HdrMetadataEXT
+    {
+    protected:
+      HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(),
+                      vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(),
+                      vk::XYColorEXT displayPrimaryBlue_ = vk::XYColorEXT(),
+                      vk::XYColorEXT whitePoint_ = vk::XYColorEXT(),
+                      float maxLuminance_ = 0,
+                      float minLuminance_ = 0,
+                      float maxContentLightLevel_ = 0,
+                      float maxFrameAverageLightLevel_ = 0 )
+        : displayPrimaryRed( displayPrimaryRed_ )
+        , displayPrimaryGreen( displayPrimaryGreen_ )
+        , displayPrimaryBlue( displayPrimaryBlue_ )
+        , whitePoint( whitePoint_ )
+        , maxLuminance( maxLuminance_ )
+        , minLuminance( minLuminance_ )
+        , maxContentLightLevel( maxContentLightLevel_ )
+        , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
+      {}
 
-  struct HdrMetadataEXT
+      HdrMetadataEXT( VkHdrMetadataEXT const & rhs )
+      {
+        *reinterpret_cast<VkHdrMetadataEXT*>(this) = rhs;
+      }
+
+      HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs )
+      {
+        *reinterpret_cast<VkHdrMetadataEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eHdrMetadataEXT;
+      const void* pNext = nullptr;
+      vk::XYColorEXT displayPrimaryRed;
+      vk::XYColorEXT displayPrimaryGreen;
+      vk::XYColorEXT displayPrimaryBlue;
+      vk::XYColorEXT whitePoint;
+      float maxLuminance;
+      float minLuminance;
+      float maxContentLightLevel;
+      float maxFrameAverageLightLevel;
+    };
+    static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct HdrMetadataEXT : public layout::HdrMetadataEXT
   {
-    HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(),
-                    XYColorEXT displayPrimaryGreen_ = XYColorEXT(),
-                    XYColorEXT displayPrimaryBlue_ = XYColorEXT(),
-                    XYColorEXT whitePoint_ = XYColorEXT(),
+    HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(),
+                    vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(),
+                    vk::XYColorEXT displayPrimaryBlue_ = vk::XYColorEXT(),
+                    vk::XYColorEXT whitePoint_ = vk::XYColorEXT(),
                     float maxLuminance_ = 0,
                     float minLuminance_ = 0,
                     float maxContentLightLevel_ = 0,
                     float maxFrameAverageLightLevel_ = 0 )
-      : displayPrimaryRed( displayPrimaryRed_ )
-      , displayPrimaryGreen( displayPrimaryGreen_ )
-      , displayPrimaryBlue( displayPrimaryBlue_ )
-      , whitePoint( whitePoint_ )
-      , maxLuminance( maxLuminance_ )
-      , minLuminance( minLuminance_ )
-      , maxContentLightLevel( maxContentLightLevel_ )
-      , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
+      : layout::HdrMetadataEXT( displayPrimaryRed_, displayPrimaryGreen_, displayPrimaryBlue_, whitePoint_, maxLuminance_, minLuminance_, maxContentLightLevel_, maxFrameAverageLightLevel_ )
     {}
 
     HdrMetadataEXT( VkHdrMetadataEXT const & rhs )
-    {
-      *reinterpret_cast<VkHdrMetadataEXT*>(this) = rhs;
-    }
+      : layout::HdrMetadataEXT( rhs )
+    {}
 
     HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs )
     {
@@ -31839,25 +36094,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    HdrMetadataEXT & setDisplayPrimaryRed( XYColorEXT displayPrimaryRed_ )
+    HdrMetadataEXT & setDisplayPrimaryRed( vk::XYColorEXT displayPrimaryRed_ )
     {
       displayPrimaryRed = displayPrimaryRed_;
       return *this;
     }
 
-    HdrMetadataEXT & setDisplayPrimaryGreen( XYColorEXT displayPrimaryGreen_ )
+    HdrMetadataEXT & setDisplayPrimaryGreen( vk::XYColorEXT displayPrimaryGreen_ )
     {
       displayPrimaryGreen = displayPrimaryGreen_;
       return *this;
     }
 
-    HdrMetadataEXT & setDisplayPrimaryBlue( XYColorEXT displayPrimaryBlue_ )
+    HdrMetadataEXT & setDisplayPrimaryBlue( vk::XYColorEXT displayPrimaryBlue_ )
     {
       displayPrimaryBlue = displayPrimaryBlue_;
       return *this;
     }
 
-    HdrMetadataEXT & setWhitePoint( XYColorEXT whitePoint_ )
+    HdrMetadataEXT & setWhitePoint( vk::XYColorEXT whitePoint_ )
     {
       whitePoint = whitePoint_;
       return *this;
@@ -31917,31 +36172,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eHdrMetadataEXT;
-
-  public:
-    const void* pNext = nullptr;
-    XYColorEXT displayPrimaryRed;
-    XYColorEXT displayPrimaryGreen;
-    XYColorEXT displayPrimaryBlue;
-    XYColorEXT whitePoint;
-    float maxLuminance;
-    float minLuminance;
-    float maxContentLightLevel;
-    float maxFrameAverageLightLevel;
+    using layout::HdrMetadataEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct HeadlessSurfaceCreateInfoEXT
+    {
+    protected:
+      HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() )
+        : flags( flags_ )
+      {}
+
+      HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(this) = rhs;
+      }
+
+      HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::HeadlessSurfaceCreateFlagsEXT flags;
+    };
+    static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct HeadlessSurfaceCreateInfoEXT
+  struct HeadlessSurfaceCreateInfoEXT : public layout::HeadlessSurfaceCreateInfoEXT
   {
-    HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateFlagsEXT flags_ = HeadlessSurfaceCreateFlagsEXT() )
-      : flags( flags_ )
+    HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() )
+      : layout::HeadlessSurfaceCreateInfoEXT( flags_ )
     {}
 
     HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::HeadlessSurfaceCreateInfoEXT( rhs )
+    {}
 
     HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs )
     {
@@ -31955,7 +36227,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    HeadlessSurfaceCreateInfoEXT & setFlags( HeadlessSurfaceCreateFlagsEXT flags_ )
+    HeadlessSurfaceCreateInfoEXT & setFlags( vk::HeadlessSurfaceCreateFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
@@ -31984,27 +36256,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    HeadlessSurfaceCreateFlagsEXT flags;
+    using layout::HeadlessSurfaceCreateInfoEXT::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_IOS_MVK
-  struct IOSSurfaceCreateInfoMVK
+
+  namespace layout
+  {
+    struct IOSSurfaceCreateInfoMVK
+    {
+    protected:
+      IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(),
+                               const void* pView_ = nullptr )
+        : flags( flags_ )
+        , pView( pView_ )
+      {}
+
+      IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
+      {
+        *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this) = rhs;
+      }
+
+      IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs )
+      {
+        *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
+      const void* pNext = nullptr;
+      vk::IOSSurfaceCreateFlagsMVK flags;
+      const void* pView;
+    };
+    static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "layout struct and wrapper have different size!" );
+  }
+
+  struct IOSSurfaceCreateInfoMVK : public layout::IOSSurfaceCreateInfoMVK
   {
-    IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(),
+    IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(),
                              const void* pView_ = nullptr )
-      : flags( flags_ )
-      , pView( pView_ )
+      : layout::IOSSurfaceCreateInfoMVK( flags_, pView_ )
     {}
 
     IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
-    {
-      *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this) = rhs;
-    }
+      : layout::IOSSurfaceCreateInfoMVK( rhs )
+    {}
 
     IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs )
     {
@@ -32018,7 +36317,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    IOSSurfaceCreateInfoMVK & setFlags( IOSSurfaceCreateFlagsMVK flags_ )
+    IOSSurfaceCreateInfoMVK & setFlags( vk::IOSSurfaceCreateFlagsMVK flags_ )
     {
       flags = flags_;
       return *this;
@@ -32054,27 +36353,24 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
-
-  public:
-    const void* pNext = nullptr;
-    IOSSurfaceCreateFlagsMVK flags;
-    const void* pView;
+    using layout::IOSSurfaceCreateInfoMVK::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
 
   struct ImageBlit
   {
-    ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
-               std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D() } },
-               ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
-               std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D() } } )
-      : srcSubresource( srcSubresource_ )
-      , dstSubresource( dstSubresource_ )
+    ImageBlit( vk::ImageSubresourceLayers srcSubresource_ = vk::ImageSubresourceLayers(),
+               std::array<vk::Offset3D,2> const& srcOffsets_ = { { vk::Offset3D() } },
+               vk::ImageSubresourceLayers dstSubresource_ = vk::ImageSubresourceLayers(),
+               std::array<vk::Offset3D,2> const& dstOffsets_ = { { vk::Offset3D() } } )
+        : srcSubresource( srcSubresource_ )
+        , dstSubresource( dstSubresource_ )
     {
-      memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
-      memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+        memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( vk::Offset3D ) );
+        memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( vk::Offset3D ) );
+    
     }
 
     ImageBlit( VkImageBlit const & rhs )
@@ -32088,27 +36384,27 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageBlit & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+    ImageBlit & setSrcSubresource( vk::ImageSubresourceLayers srcSubresource_ )
     {
       srcSubresource = srcSubresource_;
       return *this;
     }
 
-    ImageBlit & setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
+    ImageBlit & setSrcOffsets( std::array<vk::Offset3D,2> srcOffsets_ )
     {
-      memcpy( srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+      memcpy( srcOffsets, srcOffsets_.data(), 2 * sizeof( vk::Offset3D ) );
       return *this;
     }
 
-    ImageBlit & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+    ImageBlit & setDstSubresource( vk::ImageSubresourceLayers dstSubresource_ )
     {
       dstSubresource = dstSubresource_;
       return *this;
     }
 
-    ImageBlit & setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
+    ImageBlit & setDstOffsets( std::array<vk::Offset3D,2> dstOffsets_ )
     {
-      memcpy( dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+      memcpy( dstOffsets, dstOffsets_.data(), 2 * sizeof( vk::Offset3D ) );
       return *this;
     }
 
@@ -32125,9 +36421,9 @@ namespace VULKAN_HPP_NAMESPACE
     bool operator==( ImageBlit const& rhs ) const
     {
       return ( srcSubresource == rhs.srcSubresource )
-          && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
+          && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( vk::Offset3D ) ) == 0 )
           && ( dstSubresource == rhs.dstSubresource )
-          && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
+          && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( vk::Offset3D ) ) == 0 );
     }
 
     bool operator!=( ImageBlit const& rhs ) const
@@ -32135,25 +36431,27 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffsets[2];
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffsets[2];
+  public:
+    vk::ImageSubresourceLayers srcSubresource;
+    vk::Offset3D srcOffsets[2];
+    vk::ImageSubresourceLayers dstSubresource;
+    vk::Offset3D dstOffsets[2];
   };
   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
   {
-    ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
-               Offset3D srcOffset_ = Offset3D(),
-               ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
-               Offset3D dstOffset_ = Offset3D(),
-               Extent3D extent_ = Extent3D() )
-      : srcSubresource( srcSubresource_ )
-      , srcOffset( srcOffset_ )
-      , dstSubresource( dstSubresource_ )
-      , dstOffset( dstOffset_ )
-      , extent( extent_ )
+    ImageCopy( vk::ImageSubresourceLayers srcSubresource_ = vk::ImageSubresourceLayers(),
+               vk::Offset3D srcOffset_ = vk::Offset3D(),
+               vk::ImageSubresourceLayers dstSubresource_ = vk::ImageSubresourceLayers(),
+               vk::Offset3D dstOffset_ = vk::Offset3D(),
+               vk::Extent3D extent_ = vk::Extent3D() )
+        : srcSubresource( srcSubresource_ )
+        , srcOffset( srcOffset_ )
+        , dstSubresource( dstSubresource_ )
+        , dstOffset( dstOffset_ )
+        , extent( extent_ )
     {}
 
     ImageCopy( VkImageCopy const & rhs )
@@ -32167,31 +36465,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageCopy & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+    ImageCopy & setSrcSubresource( vk::ImageSubresourceLayers srcSubresource_ )
     {
       srcSubresource = srcSubresource_;
       return *this;
     }
 
-    ImageCopy & setSrcOffset( Offset3D srcOffset_ )
+    ImageCopy & setSrcOffset( vk::Offset3D srcOffset_ )
     {
       srcOffset = srcOffset_;
       return *this;
     }
 
-    ImageCopy & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+    ImageCopy & setDstSubresource( vk::ImageSubresourceLayers dstSubresource_ )
     {
       dstSubresource = dstSubresource_;
       return *this;
     }
 
-    ImageCopy & setDstOffset( Offset3D dstOffset_ )
+    ImageCopy & setDstOffset( vk::Offset3D dstOffset_ )
     {
       dstOffset = dstOffset_;
       return *this;
     }
 
-    ImageCopy & setExtent( Extent3D extent_ )
+    ImageCopy & setExtent( vk::Extent3D extent_ )
     {
       extent = extent_;
       return *this;
@@ -32221,48 +36519,101 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffset;
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffset;
-    Extent3D extent;
+  public:
+    vk::ImageSubresourceLayers srcSubresource;
+    vk::Offset3D srcOffset;
+    vk::ImageSubresourceLayers dstSubresource;
+    vk::Offset3D dstOffset;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct ImageCreateInfo
+    {
+    protected:
+      ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
+                       vk::ImageType imageType_ = vk::ImageType::e1D,
+                       vk::Format format_ = vk::Format::eUndefined,
+                       vk::Extent3D extent_ = vk::Extent3D(),
+                       uint32_t mipLevels_ = 0,
+                       uint32_t arrayLayers_ = 0,
+                       vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+                       vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal,
+                       vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+                       vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+                       uint32_t queueFamilyIndexCount_ = 0,
+                       const uint32_t* pQueueFamilyIndices_ = nullptr,
+                       vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined )
+        : flags( flags_ )
+        , imageType( imageType_ )
+        , format( format_ )
+        , extent( extent_ )
+        , mipLevels( mipLevels_ )
+        , arrayLayers( arrayLayers_ )
+        , samples( samples_ )
+        , tiling( tiling_ )
+        , usage( usage_ )
+        , sharingMode( sharingMode_ )
+        , queueFamilyIndexCount( queueFamilyIndexCount_ )
+        , pQueueFamilyIndices( pQueueFamilyIndices_ )
+        , initialLayout( initialLayout_ )
+      {}
 
-  struct ImageCreateInfo
+      ImageCreateInfo( VkImageCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkImageCreateInfo*>(this) = rhs;
+      }
+
+      ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkImageCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageCreateInfo;
+      const void* pNext = nullptr;
+      vk::ImageCreateFlags flags;
+      vk::ImageType imageType;
+      vk::Format format;
+      vk::Extent3D extent;
+      uint32_t mipLevels;
+      uint32_t arrayLayers;
+      vk::SampleCountFlagBits samples;
+      vk::ImageTiling tiling;
+      vk::ImageUsageFlags usage;
+      vk::SharingMode sharingMode;
+      uint32_t queueFamilyIndexCount;
+      const uint32_t* pQueueFamilyIndices;
+      vk::ImageLayout initialLayout;
+    };
+    static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImageCreateInfo : public layout::ImageCreateInfo
   {
-    ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(),
-                     ImageType imageType_ = ImageType::e1D,
-                     Format format_ = Format::eUndefined,
-                     Extent3D extent_ = Extent3D(),
+    ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
+                     vk::ImageType imageType_ = vk::ImageType::e1D,
+                     vk::Format format_ = vk::Format::eUndefined,
+                     vk::Extent3D extent_ = vk::Extent3D(),
                      uint32_t mipLevels_ = 0,
                      uint32_t arrayLayers_ = 0,
-                     SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
-                     ImageTiling tiling_ = ImageTiling::eOptimal,
-                     ImageUsageFlags usage_ = ImageUsageFlags(),
-                     SharingMode sharingMode_ = SharingMode::eExclusive,
+                     vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+                     vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal,
+                     vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+                     vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
                      uint32_t queueFamilyIndexCount_ = 0,
                      const uint32_t* pQueueFamilyIndices_ = nullptr,
-                     ImageLayout initialLayout_ = ImageLayout::eUndefined )
-      : flags( flags_ )
-      , imageType( imageType_ )
-      , format( format_ )
-      , extent( extent_ )
-      , mipLevels( mipLevels_ )
-      , arrayLayers( arrayLayers_ )
-      , samples( samples_ )
-      , tiling( tiling_ )
-      , usage( usage_ )
-      , sharingMode( sharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
-      , initialLayout( initialLayout_ )
+                     vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined )
+      : layout::ImageCreateInfo( flags_, imageType_, format_, extent_, mipLevels_, arrayLayers_, samples_, tiling_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, initialLayout_ )
     {}
 
     ImageCreateInfo( VkImageCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkImageCreateInfo*>(this) = rhs;
-    }
+      : layout::ImageCreateInfo( rhs )
+    {}
 
     ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
     {
@@ -32276,25 +36627,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageCreateInfo & setFlags( ImageCreateFlags flags_ )
+    ImageCreateInfo & setFlags( vk::ImageCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ImageCreateInfo & setImageType( ImageType imageType_ )
+    ImageCreateInfo & setImageType( vk::ImageType imageType_ )
     {
       imageType = imageType_;
       return *this;
     }
 
-    ImageCreateInfo & setFormat( Format format_ )
+    ImageCreateInfo & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    ImageCreateInfo & setExtent( Extent3D extent_ )
+    ImageCreateInfo & setExtent( vk::Extent3D extent_ )
     {
       extent = extent_;
       return *this;
@@ -32312,25 +36663,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageCreateInfo & setSamples( SampleCountFlagBits samples_ )
+    ImageCreateInfo & setSamples( vk::SampleCountFlagBits samples_ )
     {
       samples = samples_;
       return *this;
     }
 
-    ImageCreateInfo & setTiling( ImageTiling tiling_ )
+    ImageCreateInfo & setTiling( vk::ImageTiling tiling_ )
     {
       tiling = tiling_;
       return *this;
     }
 
-    ImageCreateInfo & setUsage( ImageUsageFlags usage_ )
+    ImageCreateInfo & setUsage( vk::ImageUsageFlags usage_ )
     {
       usage = usage_;
       return *this;
     }
 
-    ImageCreateInfo & setSharingMode( SharingMode sharingMode_ )
+    ImageCreateInfo & setSharingMode( vk::SharingMode sharingMode_ )
     {
       sharingMode = sharingMode_;
       return *this;
@@ -32348,7 +36699,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageCreateInfo & setInitialLayout( ImageLayout initialLayout_ )
+    ImageCreateInfo & setInitialLayout( vk::ImageLayout initialLayout_ )
     {
       initialLayout = initialLayout_;
       return *this;
@@ -32389,25 +36740,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageCreateFlags flags;
-    ImageType imageType;
-    Format format;
-    Extent3D extent;
-    uint32_t mipLevels;
-    uint32_t arrayLayers;
-    SampleCountFlagBits samples;
-    ImageTiling tiling;
-    ImageUsageFlags usage;
-    SharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
-    ImageLayout initialLayout;
+    using layout::ImageCreateInfo::sType;
   };
   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!" );
 
   struct SubresourceLayout
   {
@@ -32435,28 +36771,61 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DeviceSize offset;
-    DeviceSize size;
-    DeviceSize rowPitch;
-    DeviceSize arrayPitch;
-    DeviceSize depthPitch;
+  public:
+    vk::DeviceSize offset;
+    vk::DeviceSize size;
+    vk::DeviceSize rowPitch;
+    vk::DeviceSize arrayPitch;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct ImageDrmFormatModifierExplicitCreateInfoEXT
+    {
+    protected:
+      ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
+                                                   uint32_t drmFormatModifierPlaneCount_ = 0,
+                                                   const vk::SubresourceLayout* pPlaneLayouts_ = nullptr )
+        : drmFormatModifier( drmFormatModifier_ )
+        , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
+        , pPlaneLayouts( pPlaneLayouts_ )
+      {}
+
+      ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this) = rhs;
+      }
+
+      ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
+      const void* pNext = nullptr;
+      uint64_t drmFormatModifier;
+      uint32_t drmFormatModifierPlaneCount;
+      const vk::SubresourceLayout* pPlaneLayouts;
+    };
+    static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ImageDrmFormatModifierExplicitCreateInfoEXT
+  struct ImageDrmFormatModifierExplicitCreateInfoEXT : public layout::ImageDrmFormatModifierExplicitCreateInfoEXT
   {
     ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
                                                  uint32_t drmFormatModifierPlaneCount_ = 0,
-                                                 const SubresourceLayout* pPlaneLayouts_ = nullptr )
-      : drmFormatModifier( drmFormatModifier_ )
-      , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
-      , pPlaneLayouts( pPlaneLayouts_ )
+                                                 const vk::SubresourceLayout* pPlaneLayouts_ = nullptr )
+      : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( drmFormatModifier_, drmFormatModifierPlaneCount_, pPlaneLayouts_ )
     {}
 
     ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( rhs )
+    {}
 
     ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
     {
@@ -32482,7 +36851,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts( const SubresourceLayout* pPlaneLayouts_ )
+    ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts( const vk::SubresourceLayout* pPlaneLayouts_ )
     {
       pPlaneLayouts = pPlaneLayouts_;
       return *this;
@@ -32513,28 +36882,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint64_t drmFormatModifier;
-    uint32_t drmFormatModifierPlaneCount;
-    const SubresourceLayout* pPlaneLayouts;
+    using layout::ImageDrmFormatModifierExplicitCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImageDrmFormatModifierListCreateInfoEXT
+    {
+    protected:
+      ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
+                                               const uint64_t* pDrmFormatModifiers_ = nullptr )
+        : drmFormatModifierCount( drmFormatModifierCount_ )
+        , pDrmFormatModifiers( pDrmFormatModifiers_ )
+      {}
+
+      ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this) = rhs;
+      }
 
-  struct ImageDrmFormatModifierListCreateInfoEXT
+      ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
+      const void* pNext = nullptr;
+      uint32_t drmFormatModifierCount;
+      const uint64_t* pDrmFormatModifiers;
+    };
+    static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImageDrmFormatModifierListCreateInfoEXT : public layout::ImageDrmFormatModifierListCreateInfoEXT
   {
     ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
                                              const uint64_t* pDrmFormatModifiers_ = nullptr )
-      : drmFormatModifierCount( drmFormatModifierCount_ )
-      , pDrmFormatModifiers( pDrmFormatModifiers_ )
+      : layout::ImageDrmFormatModifierListCreateInfoEXT( drmFormatModifierCount_, pDrmFormatModifiers_ )
     {}
 
     ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::ImageDrmFormatModifierListCreateInfoEXT( rhs )
+    {}
 
     ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
     {
@@ -32584,16 +36977,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t drmFormatModifierCount;
-    const uint64_t* pDrmFormatModifiers;
+    using layout::ImageDrmFormatModifierListCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImageDrmFormatModifierPropertiesEXT
+    {
+    protected:
+      ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = 0 )
+        : drmFormatModifier( drmFormatModifier_ )
+      {}
+
+      ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this) = rhs;
+      }
 
-  struct ImageDrmFormatModifierPropertiesEXT
+      ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
+      void* pNext = nullptr;
+      uint64_t drmFormatModifier;
+    };
+    static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImageDrmFormatModifierPropertiesEXT : public layout::ImageDrmFormatModifierPropertiesEXT
   {
     operator VkImageDrmFormatModifierPropertiesEXT const&() const
     {
@@ -32618,26 +37035,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint64_t drmFormatModifier;
+    using layout::ImageDrmFormatModifierPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImageFormatListCreateInfoKHR
+    {
+    protected:
+      ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
+                                    const vk::Format* pViewFormats_ = nullptr )
+        : viewFormatCount( viewFormatCount_ )
+        , pViewFormats( pViewFormats_ )
+      {}
+
+      ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this) = rhs;
+      }
+
+      ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct ImageFormatListCreateInfoKHR
+    public:
+      vk::StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
+      const void* pNext = nullptr;
+      uint32_t viewFormatCount;
+      const vk::Format* pViewFormats;
+    };
+    static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImageFormatListCreateInfoKHR : public layout::ImageFormatListCreateInfoKHR
   {
     ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
-                                  const Format* pViewFormats_ = nullptr )
-      : viewFormatCount( viewFormatCount_ )
-      , pViewFormats( pViewFormats_ )
+                                  const vk::Format* pViewFormats_ = nullptr )
+      : layout::ImageFormatListCreateInfoKHR( viewFormatCount_, pViewFormats_ )
     {}
 
     ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::ImageFormatListCreateInfoKHR( rhs )
+    {}
 
     ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs )
     {
@@ -32657,7 +37100,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageFormatListCreateInfoKHR & setPViewFormats( const Format* pViewFormats_ )
+    ImageFormatListCreateInfoKHR & setPViewFormats( const vk::Format* pViewFormats_ )
     {
       pViewFormats = pViewFormats_;
       return *this;
@@ -32687,16 +37130,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t viewFormatCount;
-    const Format* pViewFormats;
+    using layout::ImageFormatListCreateInfoKHR::sType;
   };
   static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ImageFormatListCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct ImageFormatProperties2
+    {
+    protected:
+      ImageFormatProperties2( vk::ImageFormatProperties imageFormatProperties_ = vk::ImageFormatProperties() )
+        : imageFormatProperties( imageFormatProperties_ )
+      {}
+
+      ImageFormatProperties2( VkImageFormatProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkImageFormatProperties2*>(this) = rhs;
+      }
 
-  struct ImageFormatProperties2
+      ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkImageFormatProperties2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageFormatProperties2;
+      void* pNext = nullptr;
+      vk::ImageFormatProperties imageFormatProperties;
+    };
+    static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImageFormatProperties2 : public layout::ImageFormatProperties2
   {
     operator VkImageFormatProperties2 const&() const
     {
@@ -32721,26 +37188,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageFormatProperties2;
-
-  public:
-    void* pNext = nullptr;
-    ImageFormatProperties imageFormatProperties;
+    using layout::ImageFormatProperties2::sType;
   };
   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!" );
 
   struct ImageSubresourceRange
   {
-    ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+    ImageSubresourceRange( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
                            uint32_t baseMipLevel_ = 0,
                            uint32_t levelCount_ = 0,
                            uint32_t baseArrayLayer_ = 0,
                            uint32_t layerCount_ = 0 )
-      : aspectMask( aspectMask_ )
-      , baseMipLevel( baseMipLevel_ )
-      , levelCount( levelCount_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
+        : aspectMask( aspectMask_ )
+        , baseMipLevel( baseMipLevel_ )
+        , levelCount( levelCount_ )
+        , baseArrayLayer( baseArrayLayer_ )
+        , layerCount( layerCount_ )
     {}
 
     ImageSubresourceRange( VkImageSubresourceRange const & rhs )
@@ -32754,7 +37218,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageSubresourceRange & setAspectMask( ImageAspectFlags aspectMask_ )
+    ImageSubresourceRange & setAspectMask( vk::ImageAspectFlags aspectMask_ )
     {
       aspectMask = aspectMask_;
       return *this;
@@ -32808,38 +37272,81 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageAspectFlags aspectMask;
+  public:
+    vk::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!" );
+
+  namespace layout
+  {
+    struct ImageMemoryBarrier
+    {
+    protected:
+      ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                          vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+                          vk::ImageLayout oldLayout_ = vk::ImageLayout::eUndefined,
+                          vk::ImageLayout newLayout_ = vk::ImageLayout::eUndefined,
+                          uint32_t srcQueueFamilyIndex_ = 0,
+                          uint32_t dstQueueFamilyIndex_ = 0,
+                          vk::Image image_ = vk::Image(),
+                          vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() )
+        : srcAccessMask( srcAccessMask_ )
+        , dstAccessMask( dstAccessMask_ )
+        , oldLayout( oldLayout_ )
+        , newLayout( newLayout_ )
+        , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+        , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+        , image( image_ )
+        , subresourceRange( subresourceRange_ )
+      {}
+
+      ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
+      {
+        *reinterpret_cast<VkImageMemoryBarrier*>(this) = rhs;
+      }
+
+      ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
+      {
+        *reinterpret_cast<VkImageMemoryBarrier*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageMemoryBarrier;
+      const void* pNext = nullptr;
+      vk::AccessFlags srcAccessMask;
+      vk::AccessFlags dstAccessMask;
+      vk::ImageLayout oldLayout;
+      vk::ImageLayout newLayout;
+      uint32_t srcQueueFamilyIndex;
+      uint32_t dstQueueFamilyIndex;
+      vk::Image image;
+      vk::ImageSubresourceRange subresourceRange;
+    };
+    static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ImageMemoryBarrier
+  struct ImageMemoryBarrier : public layout::ImageMemoryBarrier
   {
-    ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
-                        AccessFlags dstAccessMask_ = AccessFlags(),
-                        ImageLayout oldLayout_ = ImageLayout::eUndefined,
-                        ImageLayout newLayout_ = ImageLayout::eUndefined,
+    ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                        vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+                        vk::ImageLayout oldLayout_ = vk::ImageLayout::eUndefined,
+                        vk::ImageLayout newLayout_ = vk::ImageLayout::eUndefined,
                         uint32_t srcQueueFamilyIndex_ = 0,
                         uint32_t dstQueueFamilyIndex_ = 0,
-                        Image image_ = Image(),
-                        ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , oldLayout( oldLayout_ )
-      , newLayout( newLayout_ )
-      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
-      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
-      , image( image_ )
-      , subresourceRange( subresourceRange_ )
+                        vk::Image image_ = vk::Image(),
+                        vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() )
+      : layout::ImageMemoryBarrier( srcAccessMask_, dstAccessMask_, oldLayout_, newLayout_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, image_, subresourceRange_ )
     {}
 
     ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
-    {
-      *reinterpret_cast<VkImageMemoryBarrier*>(this) = rhs;
-    }
+      : layout::ImageMemoryBarrier( rhs )
+    {}
 
     ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
     {
@@ -32853,25 +37360,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    ImageMemoryBarrier & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
     {
       srcAccessMask = srcAccessMask_;
       return *this;
     }
 
-    ImageMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+    ImageMemoryBarrier & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
     {
       dstAccessMask = dstAccessMask_;
       return *this;
     }
 
-    ImageMemoryBarrier & setOldLayout( ImageLayout oldLayout_ )
+    ImageMemoryBarrier & setOldLayout( vk::ImageLayout oldLayout_ )
     {
       oldLayout = oldLayout_;
       return *this;
     }
 
-    ImageMemoryBarrier & setNewLayout( ImageLayout newLayout_ )
+    ImageMemoryBarrier & setNewLayout( vk::ImageLayout newLayout_ )
     {
       newLayout = newLayout_;
       return *this;
@@ -32889,13 +37396,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageMemoryBarrier & setImage( Image image_ )
+    ImageMemoryBarrier & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
     }
 
-    ImageMemoryBarrier & setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+    ImageMemoryBarrier & setSubresourceRange( vk::ImageSubresourceRange subresourceRange_ )
     {
       subresourceRange = subresourceRange_;
       return *this;
@@ -32931,31 +37438,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    ImageLayout oldLayout;
-    ImageLayout newLayout;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    Image image;
-    ImageSubresourceRange subresourceRange;
+    using layout::ImageMemoryBarrier::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImageMemoryRequirementsInfo2
+    {
+    protected:
+      ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() )
+        : image( image_ )
+      {}
+
+      ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this) = rhs;
+      }
+
+      ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this) = rhs;
+        return *this;
+      }
 
-  struct ImageMemoryRequirementsInfo2
+    public:
+      vk::StructureType sType = StructureType::eImageMemoryRequirementsInfo2;
+      const void* pNext = nullptr;
+      vk::Image image;
+    };
+    static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImageMemoryRequirementsInfo2 : public layout::ImageMemoryRequirementsInfo2
   {
-    ImageMemoryRequirementsInfo2( Image image_ = Image() )
-      : image( image_ )
+    ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() )
+      : layout::ImageMemoryRequirementsInfo2( image_ )
     {}
 
     ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs )
-    {
-      *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this) = rhs;
-    }
+      : layout::ImageMemoryRequirementsInfo2( rhs )
+    {}
 
     ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs )
     {
@@ -32969,7 +37493,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageMemoryRequirementsInfo2 & setImage( Image image_ )
+    ImageMemoryRequirementsInfo2 & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
@@ -32998,27 +37522,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageMemoryRequirementsInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
+    using layout::ImageMemoryRequirementsInfo2::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_FUCHSIA
-  struct ImagePipeSurfaceCreateInfoFUCHSIA
+
+  namespace layout
   {
-    ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = ImagePipeSurfaceCreateFlagsFUCHSIA(),
+    struct ImagePipeSurfaceCreateInfoFUCHSIA
+    {
+    protected:
+      ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(),
+                                         zx_handle_t imagePipeHandle_ = 0 )
+        : flags( flags_ )
+        , imagePipeHandle( imagePipeHandle_ )
+      {}
+
+      ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
+      {
+        *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this) = rhs;
+      }
+
+      ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
+      {
+        *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
+      const void* pNext = nullptr;
+      vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags;
+      zx_handle_t imagePipeHandle;
+    };
+    static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImagePipeSurfaceCreateInfoFUCHSIA : public layout::ImagePipeSurfaceCreateInfoFUCHSIA
+  {
+    ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(),
                                        zx_handle_t imagePipeHandle_ = 0 )
-      : flags( flags_ )
-      , imagePipeHandle( imagePipeHandle_ )
+      : layout::ImagePipeSurfaceCreateInfoFUCHSIA( flags_, imagePipeHandle_ )
     {}
 
     ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
-    {
-      *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this) = rhs;
-    }
+      : layout::ImagePipeSurfaceCreateInfoFUCHSIA( rhs )
+    {}
 
     ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
     {
@@ -33032,7 +37583,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImagePipeSurfaceCreateInfoFUCHSIA & setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ )
+    ImagePipeSurfaceCreateInfoFUCHSIA & setFlags( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ )
     {
       flags = flags_;
       return *this;
@@ -33068,26 +37619,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
-
-  public:
-    const void* pNext = nullptr;
-    ImagePipeSurfaceCreateFlagsFUCHSIA flags;
-    zx_handle_t imagePipeHandle;
+    using layout::ImagePipeSurfaceCreateInfoFUCHSIA::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-  struct ImagePlaneMemoryRequirementsInfo
+  namespace layout
+  {
+    struct ImagePlaneMemoryRequirementsInfo
+    {
+    protected:
+      ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor )
+        : planeAspect( planeAspect_ )
+      {}
+
+      ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs )
+      {
+        *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this) = rhs;
+      }
+
+      ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs )
+      {
+        *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
+      const void* pNext = nullptr;
+      vk::ImageAspectFlagBits planeAspect;
+    };
+    static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImagePlaneMemoryRequirementsInfo : public layout::ImagePlaneMemoryRequirementsInfo
   {
-    ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
-      : planeAspect( planeAspect_ )
+    ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor )
+      : layout::ImagePlaneMemoryRequirementsInfo( planeAspect_ )
     {}
 
     ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs )
-    {
-      *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this) = rhs;
-    }
+      : layout::ImagePlaneMemoryRequirementsInfo( rhs )
+    {}
 
     ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs )
     {
@@ -33101,7 +37675,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImagePlaneMemoryRequirementsInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+    ImagePlaneMemoryRequirementsInfo & setPlaneAspect( vk::ImageAspectFlagBits planeAspect_ )
     {
       planeAspect = planeAspect_;
       return *this;
@@ -33130,26 +37704,23 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageAspectFlagBits planeAspect;
+    using layout::ImagePlaneMemoryRequirementsInfo::sType;
   };
   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!" );
 
   struct ImageResolve
   {
-    ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
-                  Offset3D srcOffset_ = Offset3D(),
-                  ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
-                  Offset3D dstOffset_ = Offset3D(),
-                  Extent3D extent_ = Extent3D() )
-      : srcSubresource( srcSubresource_ )
-      , srcOffset( srcOffset_ )
-      , dstSubresource( dstSubresource_ )
-      , dstOffset( dstOffset_ )
-      , extent( extent_ )
+    ImageResolve( vk::ImageSubresourceLayers srcSubresource_ = vk::ImageSubresourceLayers(),
+                  vk::Offset3D srcOffset_ = vk::Offset3D(),
+                  vk::ImageSubresourceLayers dstSubresource_ = vk::ImageSubresourceLayers(),
+                  vk::Offset3D dstOffset_ = vk::Offset3D(),
+                  vk::Extent3D extent_ = vk::Extent3D() )
+        : srcSubresource( srcSubresource_ )
+        , srcOffset( srcOffset_ )
+        , dstSubresource( dstSubresource_ )
+        , dstOffset( dstOffset_ )
+        , extent( extent_ )
     {}
 
     ImageResolve( VkImageResolve const & rhs )
@@ -33163,31 +37734,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageResolve & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+    ImageResolve & setSrcSubresource( vk::ImageSubresourceLayers srcSubresource_ )
     {
       srcSubresource = srcSubresource_;
       return *this;
     }
 
-    ImageResolve & setSrcOffset( Offset3D srcOffset_ )
+    ImageResolve & setSrcOffset( vk::Offset3D srcOffset_ )
     {
       srcOffset = srcOffset_;
       return *this;
     }
 
-    ImageResolve & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+    ImageResolve & setDstSubresource( vk::ImageSubresourceLayers dstSubresource_ )
     {
       dstSubresource = dstSubresource_;
       return *this;
     }
 
-    ImageResolve & setDstOffset( Offset3D dstOffset_ )
+    ImageResolve & setDstOffset( vk::Offset3D dstOffset_ )
     {
       dstOffset = dstOffset_;
       return *this;
     }
 
-    ImageResolve & setExtent( Extent3D extent_ )
+    ImageResolve & setExtent( vk::Extent3D extent_ )
     {
       extent = extent_;
       return *this;
@@ -33217,24 +37788,53 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffset;
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffset;
-    Extent3D extent;
+  public:
+    vk::ImageSubresourceLayers srcSubresource;
+    vk::Offset3D srcOffset;
+    vk::ImageSubresourceLayers dstSubresource;
+    vk::Offset3D dstOffset;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct ImageSparseMemoryRequirementsInfo2
+    {
+    protected:
+      ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() )
+        : image( image_ )
+      {}
+
+      ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this) = rhs;
+      }
+
+      ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2;
+      const void* pNext = nullptr;
+      vk::Image image;
+    };
+    static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ImageSparseMemoryRequirementsInfo2
+  struct ImageSparseMemoryRequirementsInfo2 : public layout::ImageSparseMemoryRequirementsInfo2
   {
-    ImageSparseMemoryRequirementsInfo2( Image image_ = Image() )
-      : image( image_ )
+    ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() )
+      : layout::ImageSparseMemoryRequirementsInfo2( image_ )
     {}
 
     ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs )
-    {
-      *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this) = rhs;
-    }
+      : layout::ImageSparseMemoryRequirementsInfo2( rhs )
+    {}
 
     ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs )
     {
@@ -33248,7 +37848,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageSparseMemoryRequirementsInfo2 & setImage( Image image_ )
+    ImageSparseMemoryRequirementsInfo2 & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
@@ -33277,24 +37877,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
+    using layout::ImageSparseMemoryRequirementsInfo2::sType;
   };
   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!" );
 
-  struct ImageStencilUsageCreateInfoEXT
+  namespace layout
   {
-    ImageStencilUsageCreateInfoEXT( ImageUsageFlags stencilUsage_ = ImageUsageFlags() )
-      : stencilUsage( stencilUsage_ )
+    struct ImageStencilUsageCreateInfoEXT
+    {
+    protected:
+      ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() )
+        : stencilUsage( stencilUsage_ )
+      {}
+
+      ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>(this) = rhs;
+      }
+
+      ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::ImageUsageFlags stencilUsage;
+    };
+    static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImageStencilUsageCreateInfoEXT : public layout::ImageStencilUsageCreateInfoEXT
+  {
+    ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() )
+      : layout::ImageStencilUsageCreateInfoEXT( stencilUsage_ )
     {}
 
     ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::ImageStencilUsageCreateInfoEXT( rhs )
+    {}
 
     ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs )
     {
@@ -33308,7 +37932,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageStencilUsageCreateInfoEXT & setStencilUsage( ImageUsageFlags stencilUsage_ )
+    ImageStencilUsageCreateInfoEXT & setStencilUsage( vk::ImageUsageFlags stencilUsage_ )
     {
       stencilUsage = stencilUsage_;
       return *this;
@@ -33337,24 +37961,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ImageUsageFlags stencilUsage;
+    using layout::ImageStencilUsageCreateInfoEXT::sType;
   };
   static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ImageStencilUsageCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct ImageSwapchainCreateInfoKHR
+    {
+    protected:
+      ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() )
+        : swapchain( swapchain_ )
+      {}
+
+      ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this) = rhs;
+      }
+
+      ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::SwapchainKHR swapchain;
+    };
+    static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ImageSwapchainCreateInfoKHR
+  struct ImageSwapchainCreateInfoKHR : public layout::ImageSwapchainCreateInfoKHR
   {
-    ImageSwapchainCreateInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR() )
-      : swapchain( swapchain_ )
+    ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() )
+      : layout::ImageSwapchainCreateInfoKHR( swapchain_ )
     {}
 
     ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::ImageSwapchainCreateInfoKHR( rhs )
+    {}
 
     ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs )
     {
@@ -33368,7 +38016,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageSwapchainCreateInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+    ImageSwapchainCreateInfoKHR & setSwapchain( vk::SwapchainKHR swapchain_ )
     {
       swapchain = swapchain_;
       return *this;
@@ -33397,24 +38045,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageSwapchainCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
+    using layout::ImageSwapchainCreateInfoKHR::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImageViewASTCDecodeModeEXT
+    {
+    protected:
+      ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined )
+        : decodeMode( decodeMode_ )
+      {}
 
-  struct ImageViewASTCDecodeModeEXT
+      ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this) = rhs;
+      }
+
+      ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs )
+      {
+        *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
+      const void* pNext = nullptr;
+      vk::Format decodeMode;
+    };
+    static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImageViewASTCDecodeModeEXT : public layout::ImageViewASTCDecodeModeEXT
   {
-    ImageViewASTCDecodeModeEXT( Format decodeMode_ = Format::eUndefined )
-      : decodeMode( decodeMode_ )
+    ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined )
+      : layout::ImageViewASTCDecodeModeEXT( decodeMode_ )
     {}
 
     ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs )
-    {
-      *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this) = rhs;
-    }
+      : layout::ImageViewASTCDecodeModeEXT( rhs )
+    {}
 
     ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs )
     {
@@ -33428,7 +38100,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageViewASTCDecodeModeEXT & setDecodeMode( Format decodeMode_ )
+    ImageViewASTCDecodeModeEXT & setDecodeMode( vk::Format decodeMode_ )
     {
       decodeMode = decodeMode_;
       return *this;
@@ -33457,34 +38129,68 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Format decodeMode;
+    using layout::ImageViewASTCDecodeModeEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImageViewCreateInfo
+    {
+    protected:
+      ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(),
+                           vk::Image image_ = vk::Image(),
+                           vk::ImageViewType viewType_ = vk::ImageViewType::e1D,
+                           vk::Format format_ = vk::Format::eUndefined,
+                           vk::ComponentMapping components_ = vk::ComponentMapping(),
+                           vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() )
+        : flags( flags_ )
+        , image( image_ )
+        , viewType( viewType_ )
+        , format( format_ )
+        , components( components_ )
+        , subresourceRange( subresourceRange_ )
+      {}
+
+      ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkImageViewCreateInfo*>(this) = rhs;
+      }
+
+      ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkImageViewCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageViewCreateInfo;
+      const void* pNext = nullptr;
+      vk::ImageViewCreateFlags flags;
+      vk::Image image;
+      vk::ImageViewType viewType;
+      vk::Format format;
+      vk::ComponentMapping components;
+      vk::ImageSubresourceRange subresourceRange;
+    };
+    static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ImageViewCreateInfo
+  struct ImageViewCreateInfo : public layout::ImageViewCreateInfo
   {
-    ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(),
-                         Image image_ = Image(),
-                         ImageViewType viewType_ = ImageViewType::e1D,
-                         Format format_ = Format::eUndefined,
-                         ComponentMapping components_ = ComponentMapping(),
-                         ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
-      : flags( flags_ )
-      , image( image_ )
-      , viewType( viewType_ )
-      , format( format_ )
-      , components( components_ )
-      , subresourceRange( subresourceRange_ )
+    ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(),
+                         vk::Image image_ = vk::Image(),
+                         vk::ImageViewType viewType_ = vk::ImageViewType::e1D,
+                         vk::Format format_ = vk::Format::eUndefined,
+                         vk::ComponentMapping components_ = vk::ComponentMapping(),
+                         vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() )
+      : layout::ImageViewCreateInfo( flags_, image_, viewType_, format_, components_, subresourceRange_ )
     {}
 
     ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkImageViewCreateInfo*>(this) = rhs;
-    }
+      : layout::ImageViewCreateInfo( rhs )
+    {}
 
     ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
     {
@@ -33498,37 +38204,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageViewCreateInfo & setFlags( ImageViewCreateFlags flags_ )
+    ImageViewCreateInfo & setFlags( vk::ImageViewCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ImageViewCreateInfo & setImage( Image image_ )
+    ImageViewCreateInfo & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
     }
 
-    ImageViewCreateInfo & setViewType( ImageViewType viewType_ )
+    ImageViewCreateInfo & setViewType( vk::ImageViewType viewType_ )
     {
       viewType = viewType_;
       return *this;
     }
 
-    ImageViewCreateInfo & setFormat( Format format_ )
+    ImageViewCreateInfo & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    ImageViewCreateInfo & setComponents( ComponentMapping components_ )
+    ImageViewCreateInfo & setComponents( vk::ComponentMapping components_ )
     {
       components = components_;
       return *this;
     }
 
-    ImageViewCreateInfo & setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+    ImageViewCreateInfo & setSubresourceRange( vk::ImageSubresourceRange subresourceRange_ )
     {
       subresourceRange = subresourceRange_;
       return *this;
@@ -33562,33 +38268,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageViewCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageViewCreateFlags flags;
-    Image image;
-    ImageViewType viewType;
-    Format format;
-    ComponentMapping components;
-    ImageSubresourceRange subresourceRange;
+    using layout::ImageViewCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImageViewHandleInfoNVX
+    {
+    protected:
+      ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(),
+                              vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+                              vk::Sampler sampler_ = vk::Sampler() )
+        : imageView( imageView_ )
+        , descriptorType( descriptorType_ )
+        , sampler( sampler_ )
+      {}
+
+      ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkImageViewHandleInfoNVX*>(this) = rhs;
+      }
+
+      ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkImageViewHandleInfoNVX*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageViewHandleInfoNVX;
+      const void* pNext = nullptr;
+      vk::ImageView imageView;
+      vk::DescriptorType descriptorType;
+      vk::Sampler sampler;
+    };
+    static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ImageViewHandleInfoNVX
+  struct ImageViewHandleInfoNVX : public layout::ImageViewHandleInfoNVX
   {
-    ImageViewHandleInfoNVX( ImageView imageView_ = ImageView(),
-                            DescriptorType descriptorType_ = DescriptorType::eSampler,
-                            Sampler sampler_ = Sampler() )
-      : imageView( imageView_ )
-      , descriptorType( descriptorType_ )
-      , sampler( sampler_ )
+    ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(),
+                            vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+                            vk::Sampler sampler_ = vk::Sampler() )
+      : layout::ImageViewHandleInfoNVX( imageView_, descriptorType_, sampler_ )
     {}
 
     ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs )
-    {
-      *reinterpret_cast<VkImageViewHandleInfoNVX*>(this) = rhs;
-    }
+      : layout::ImageViewHandleInfoNVX( rhs )
+    {}
 
     ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs )
     {
@@ -33602,19 +38331,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageViewHandleInfoNVX & setImageView( ImageView imageView_ )
+    ImageViewHandleInfoNVX & setImageView( vk::ImageView imageView_ )
     {
       imageView = imageView_;
       return *this;
     }
 
-    ImageViewHandleInfoNVX & setDescriptorType( DescriptorType descriptorType_ )
+    ImageViewHandleInfoNVX & setDescriptorType( vk::DescriptorType descriptorType_ )
     {
       descriptorType = descriptorType_;
       return *this;
     }
 
-    ImageViewHandleInfoNVX & setSampler( Sampler sampler_ )
+    ImageViewHandleInfoNVX & setSampler( vk::Sampler sampler_ )
     {
       sampler = sampler_;
       return *this;
@@ -33645,26 +38374,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageViewHandleInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    ImageView imageView;
-    DescriptorType descriptorType;
-    Sampler sampler;
+    using layout::ImageViewHandleInfoNVX::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImageViewUsageCreateInfo
+    {
+    protected:
+      ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() )
+        : usage( usage_ )
+      {}
+
+      ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkImageViewUsageCreateInfo*>(this) = rhs;
+      }
+
+      ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkImageViewUsageCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImageViewUsageCreateInfo;
+      const void* pNext = nullptr;
+      vk::ImageUsageFlags usage;
+    };
+    static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ImageViewUsageCreateInfo
+  struct ImageViewUsageCreateInfo : public layout::ImageViewUsageCreateInfo
   {
-    ImageViewUsageCreateInfo( ImageUsageFlags usage_ = ImageUsageFlags() )
-      : usage( usage_ )
+    ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() )
+      : layout::ImageViewUsageCreateInfo( usage_ )
     {}
 
     ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkImageViewUsageCreateInfo*>(this) = rhs;
-    }
+      : layout::ImageViewUsageCreateInfo( rhs )
+    {}
 
     ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs )
     {
@@ -33678,7 +38429,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImageViewUsageCreateInfo & setUsage( ImageUsageFlags usage_ )
+    ImageViewUsageCreateInfo & setUsage( vk::ImageUsageFlags usage_ )
     {
       usage = usage_;
       return *this;
@@ -33707,25 +38458,50 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImageViewUsageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageUsageFlags usage;
+    using layout::ImageViewUsageCreateInfo::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct ImportAndroidHardwareBufferInfoANDROID
+
+  namespace layout
+  {
+    struct ImportAndroidHardwareBufferInfoANDROID
+    {
+    protected:
+      ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr )
+        : buffer( buffer_ )
+      {}
+
+      ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
+      {
+        *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this) = rhs;
+      }
+
+      ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
+      {
+        *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
+      const void* pNext = nullptr;
+      struct AHardwareBuffer* buffer;
+    };
+    static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImportAndroidHardwareBufferInfoANDROID : public layout::ImportAndroidHardwareBufferInfoANDROID
   {
     ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr )
-      : buffer( buffer_ )
+      : layout::ImportAndroidHardwareBufferInfoANDROID( buffer_ )
     {}
 
     ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
-    {
-      *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this) = rhs;
-    }
+      : layout::ImportAndroidHardwareBufferInfoANDROID( rhs )
+    {}
 
     ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
     {
@@ -33768,31 +38544,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
-
-  public:
-    const void* pNext = nullptr;
-    struct AHardwareBuffer* buffer;
+    using layout::ImportAndroidHardwareBufferInfoANDROID::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  struct ImportFenceFdInfoKHR
+  namespace layout
+  {
+    struct ImportFenceFdInfoKHR
+    {
+    protected:
+      ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(),
+                            vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
+                            vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+                            int fd_ = 0 )
+        : fence( fence_ )
+        , flags( flags_ )
+        , handleType( handleType_ )
+        , fd( fd_ )
+      {}
+
+      ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportFenceFdInfoKHR*>(this) = rhs;
+      }
+
+      ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportFenceFdInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportFenceFdInfoKHR;
+      const void* pNext = nullptr;
+      vk::Fence fence;
+      vk::FenceImportFlags flags;
+      vk::ExternalFenceHandleTypeFlagBits handleType;
+      int fd;
+    };
+    static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImportFenceFdInfoKHR : public layout::ImportFenceFdInfoKHR
   {
-    ImportFenceFdInfoKHR( Fence fence_ = Fence(),
-                          FenceImportFlags flags_ = FenceImportFlags(),
-                          ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+    ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(),
+                          vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
+                          vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
                           int fd_ = 0 )
-      : fence( fence_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , fd( fd_ )
+      : layout::ImportFenceFdInfoKHR( fence_, flags_, handleType_, fd_ )
     {}
 
     ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkImportFenceFdInfoKHR*>(this) = rhs;
-    }
+      : layout::ImportFenceFdInfoKHR( rhs )
+    {}
 
     ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
     {
@@ -33806,19 +38612,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImportFenceFdInfoKHR & setFence( Fence fence_ )
+    ImportFenceFdInfoKHR & setFence( vk::Fence fence_ )
     {
       fence = fence_;
       return *this;
     }
 
-    ImportFenceFdInfoKHR & setFlags( FenceImportFlags flags_ )
+    ImportFenceFdInfoKHR & setFlags( vk::FenceImportFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ImportFenceFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    ImportFenceFdInfoKHR & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -33856,36 +38662,66 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportFenceFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    FenceImportFlags flags;
-    ExternalFenceHandleTypeFlagBits handleType;
-    int fd;
+    using layout::ImportFenceFdInfoKHR::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportFenceWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct ImportFenceWin32HandleInfoKHR
+    {
+    protected:
+      ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
+                                     vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
+                                     vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+                                     HANDLE handle_ = 0,
+                                     LPCWSTR name_ = nullptr )
+        : fence( fence_ )
+        , flags( flags_ )
+        , handleType( handleType_ )
+        , handle( handle_ )
+        , name( name_ )
+      {}
+
+      ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      vk::Fence fence;
+      vk::FenceImportFlags flags;
+      vk::ExternalFenceHandleTypeFlagBits handleType;
+      HANDLE handle;
+      LPCWSTR name;
+    };
+    static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImportFenceWin32HandleInfoKHR : public layout::ImportFenceWin32HandleInfoKHR
   {
-    ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(),
-                                   FenceImportFlags flags_ = FenceImportFlags(),
-                                   ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+    ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
+                                   vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
+                                   vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
                                    HANDLE handle_ = 0,
                                    LPCWSTR name_ = nullptr )
-      : fence( fence_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
+      : layout::ImportFenceWin32HandleInfoKHR( fence_, flags_, handleType_, handle_, name_ )
     {}
 
     ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::ImportFenceWin32HandleInfoKHR( rhs )
+    {}
 
     ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
     {
@@ -33899,19 +38735,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImportFenceWin32HandleInfoKHR & setFence( Fence fence_ )
+    ImportFenceWin32HandleInfoKHR & setFence( vk::Fence fence_ )
     {
       fence = fence_;
       return *this;
     }
 
-    ImportFenceWin32HandleInfoKHR & setFlags( FenceImportFlags flags_ )
+    ImportFenceWin32HandleInfoKHR & setFlags( vk::FenceImportFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ImportFenceWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    ImportFenceWin32HandleInfoKHR & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -33956,31 +38792,53 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    FenceImportFlags flags;
-    ExternalFenceHandleTypeFlagBits handleType;
-    HANDLE handle;
-    LPCWSTR name;
+    using layout::ImportFenceWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct ImportMemoryFdInfoKHR
+  namespace layout
+  {
+    struct ImportMemoryFdInfoKHR
+    {
+    protected:
+      ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+                             int fd_ = 0 )
+        : handleType( handleType_ )
+        , fd( fd_ )
+      {}
+
+      ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this) = rhs;
+      }
+
+      ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportMemoryFdInfoKHR;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlagBits handleType;
+      int fd;
+    };
+    static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImportMemoryFdInfoKHR : public layout::ImportMemoryFdInfoKHR
   {
-    ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+    ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                            int fd_ = 0 )
-      : handleType( handleType_ )
-      , fd( fd_ )
+      : layout::ImportMemoryFdInfoKHR( handleType_, fd_ )
     {}
 
     ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this) = rhs;
-    }
+      : layout::ImportMemoryFdInfoKHR( rhs )
+    {}
 
     ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
     {
@@ -33994,7 +38852,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImportMemoryFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    ImportMemoryFdInfoKHR & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -34030,27 +38888,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportMemoryFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBits handleType;
-    int fd;
+    using layout::ImportMemoryFdInfoKHR::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ImportMemoryHostPointerInfoEXT
+    {
+    protected:
+      ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+                                      void* pHostPointer_ = nullptr )
+        : handleType( handleType_ )
+        , pHostPointer( pHostPointer_ )
+      {}
+
+      ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this) = rhs;
+      }
+
+      ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlagBits handleType;
+      void* pHostPointer;
+    };
+    static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ImportMemoryHostPointerInfoEXT
+  struct ImportMemoryHostPointerInfoEXT : public layout::ImportMemoryHostPointerInfoEXT
   {
-    ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+    ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                                     void* pHostPointer_ = nullptr )
-      : handleType( handleType_ )
-      , pHostPointer( pHostPointer_ )
+      : layout::ImportMemoryHostPointerInfoEXT( handleType_, pHostPointer_ )
     {}
 
     ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this) = rhs;
-    }
+      : layout::ImportMemoryHostPointerInfoEXT( rhs )
+    {}
 
     ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
     {
@@ -34064,7 +38947,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImportMemoryHostPointerInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    ImportMemoryHostPointerInfoEXT & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -34100,30 +38983,58 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBits handleType;
-    void* pHostPointer;
+    using layout::ImportMemoryHostPointerInfoEXT::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportMemoryWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct ImportMemoryWin32HandleInfoKHR
+    {
+    protected:
+      ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+                                      HANDLE handle_ = 0,
+                                      LPCWSTR name_ = nullptr )
+        : handleType( handleType_ )
+        , handle( handle_ )
+        , name( name_ )
+      {}
+
+      ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlagBits handleType;
+      HANDLE handle;
+      LPCWSTR name;
+    };
+    static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImportMemoryWin32HandleInfoKHR : public layout::ImportMemoryWin32HandleInfoKHR
   {
-    ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+    ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                                     HANDLE handle_ = 0,
                                     LPCWSTR name_ = nullptr )
-      : handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
+      : layout::ImportMemoryWin32HandleInfoKHR( handleType_, handle_, name_ )
     {}
 
     ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::ImportMemoryWin32HandleInfoKHR( rhs )
+    {}
 
     ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
     {
@@ -34137,7 +39048,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImportMemoryWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    ImportMemoryWin32HandleInfoKHR & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -34180,30 +39091,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBits handleType;
-    HANDLE handle;
-    LPCWSTR name;
+    using layout::ImportMemoryWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportMemoryWin32HandleInfoNV
+
+  namespace layout
+  {
+    struct ImportMemoryWin32HandleInfoNV
+    {
+    protected:
+      ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(),
+                                     HANDLE handle_ = 0 )
+        : handleType( handleType_ )
+        , handle( handle_ )
+      {}
+
+      ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this) = rhs;
+      }
+
+      ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlagsNV handleType;
+      HANDLE handle;
+    };
+    static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImportMemoryWin32HandleInfoNV : public layout::ImportMemoryWin32HandleInfoNV
   {
-    ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(),
+    ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(),
                                    HANDLE handle_ = 0 )
-      : handleType( handleType_ )
-      , handle( handle_ )
+      : layout::ImportMemoryWin32HandleInfoNV( handleType_, handle_ )
     {}
 
     ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this) = rhs;
-    }
+      : layout::ImportMemoryWin32HandleInfoNV( rhs )
+    {}
 
     ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
     {
@@ -34217,7 +39153,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImportMemoryWin32HandleInfoNV & setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
+    ImportMemoryWin32HandleInfoNV & setHandleType( vk::ExternalMemoryHandleTypeFlagsNV handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -34253,32 +39189,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleType;
-    HANDLE handle;
+    using layout::ImportMemoryWin32HandleInfoNV::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct ImportSemaphoreFdInfoKHR
+  namespace layout
+  {
+    struct ImportSemaphoreFdInfoKHR
+    {
+    protected:
+      ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+                                vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
+                                vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+                                int fd_ = 0 )
+        : semaphore( semaphore_ )
+        , flags( flags_ )
+        , handleType( handleType_ )
+        , fd( fd_ )
+      {}
+
+      ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this) = rhs;
+      }
+
+      ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
+      const void* pNext = nullptr;
+      vk::Semaphore semaphore;
+      vk::SemaphoreImportFlags flags;
+      vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+      int fd;
+    };
+    static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImportSemaphoreFdInfoKHR : public layout::ImportSemaphoreFdInfoKHR
   {
-    ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(),
-                              SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
-                              ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+    ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+                              vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
+                              vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
                               int fd_ = 0 )
-      : semaphore( semaphore_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , fd( fd_ )
+      : layout::ImportSemaphoreFdInfoKHR( semaphore_, flags_, handleType_, fd_ )
     {}
 
     ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this) = rhs;
-    }
+      : layout::ImportSemaphoreFdInfoKHR( rhs )
+    {}
 
     ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
     {
@@ -34292,19 +39257,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImportSemaphoreFdInfoKHR & setSemaphore( Semaphore semaphore_ )
+    ImportSemaphoreFdInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
     {
       semaphore = semaphore_;
       return *this;
     }
 
-    ImportSemaphoreFdInfoKHR & setFlags( SemaphoreImportFlags flags_ )
+    ImportSemaphoreFdInfoKHR & setFlags( vk::SemaphoreImportFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ImportSemaphoreFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    ImportSemaphoreFdInfoKHR & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -34342,36 +39307,66 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    SemaphoreImportFlags flags;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
-    int fd;
+    using layout::ImportSemaphoreFdInfoKHR::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportSemaphoreWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct ImportSemaphoreWin32HandleInfoKHR
+    {
+    protected:
+      ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+                                         vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
+                                         vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+                                         HANDLE handle_ = 0,
+                                         LPCWSTR name_ = nullptr )
+        : semaphore( semaphore_ )
+        , flags( flags_ )
+        , handleType( handleType_ )
+        , handle( handle_ )
+        , name( name_ )
+      {}
+
+      ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      vk::Semaphore semaphore;
+      vk::SemaphoreImportFlags flags;
+      vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+      HANDLE handle;
+      LPCWSTR name;
+    };
+    static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ImportSemaphoreWin32HandleInfoKHR : public layout::ImportSemaphoreWin32HandleInfoKHR
   {
-    ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
-                                       SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
-                                       ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+    ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+                                       vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
+                                       vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
                                        HANDLE handle_ = 0,
                                        LPCWSTR name_ = nullptr )
-      : semaphore( semaphore_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
+      : layout::ImportSemaphoreWin32HandleInfoKHR( semaphore_, flags_, handleType_, handle_, name_ )
     {}
 
     ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::ImportSemaphoreWin32HandleInfoKHR( rhs )
+    {}
 
     ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
     {
@@ -34385,19 +39380,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ImportSemaphoreWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ )
+    ImportSemaphoreWin32HandleInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
     {
       semaphore = semaphore_;
       return *this;
     }
 
-    ImportSemaphoreWin32HandleInfoKHR & setFlags( SemaphoreImportFlags flags_ )
+    ImportSemaphoreWin32HandleInfoKHR & setFlags( vk::SemaphoreImportFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ImportSemaphoreWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    ImportSemaphoreWin32HandleInfoKHR & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -34442,29 +39437,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    SemaphoreImportFlags flags;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
-    HANDLE handle;
-    LPCWSTR name;
+    using layout::ImportSemaphoreWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct IndirectCommandsLayoutTokenNVX
   {
-    IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
+    IndirectCommandsLayoutTokenNVX( vk::IndirectCommandsTokenTypeNVX tokenType_ = vk::IndirectCommandsTokenTypeNVX::ePipeline,
                                     uint32_t bindingUnit_ = 0,
                                     uint32_t dynamicCount_ = 0,
                                     uint32_t divisor_ = 0 )
-      : tokenType( tokenType_ )
-      , bindingUnit( bindingUnit_ )
-      , dynamicCount( dynamicCount_ )
-      , divisor( divisor_ )
+        : tokenType( tokenType_ )
+        , bindingUnit( bindingUnit_ )
+        , dynamicCount( dynamicCount_ )
+        , divisor( divisor_ )
     {}
 
     IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
@@ -34478,7 +39466,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    IndirectCommandsLayoutTokenNVX & setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+    IndirectCommandsLayoutTokenNVX & setTokenType( vk::IndirectCommandsTokenTypeNVX tokenType_ )
     {
       tokenType = tokenType_;
       return *this;
@@ -34525,29 +39513,64 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    IndirectCommandsTokenTypeNVX tokenType;
+  public:
+    vk::IndirectCommandsTokenTypeNVX tokenType;
     uint32_t bindingUnit;
     uint32_t dynamicCount;
     uint32_t divisor;
   };
   static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<IndirectCommandsLayoutTokenNVX>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct IndirectCommandsLayoutCreateInfoNVX
+    {
+    protected:
+      IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+                                           vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(),
+                                           uint32_t tokenCount_ = 0,
+                                           const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
+        : pipelineBindPoint( pipelineBindPoint_ )
+        , flags( flags_ )
+        , tokenCount( tokenCount_ )
+        , pTokens( pTokens_ )
+      {}
+
+      IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this) = rhs;
+      }
 
-  struct IndirectCommandsLayoutCreateInfoNVX
+      IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
+      const void* pNext = nullptr;
+      vk::PipelineBindPoint pipelineBindPoint;
+      vk::IndirectCommandsLayoutUsageFlagsNVX flags;
+      uint32_t tokenCount;
+      const vk::IndirectCommandsLayoutTokenNVX* pTokens;
+    };
+    static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "layout struct and wrapper have different size!" );
+  }
+
+  struct IndirectCommandsLayoutCreateInfoNVX : public layout::IndirectCommandsLayoutCreateInfoNVX
   {
-    IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
-                                         IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(),
+    IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+                                         vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(),
                                          uint32_t tokenCount_ = 0,
-                                         const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
-      : pipelineBindPoint( pipelineBindPoint_ )
-      , flags( flags_ )
-      , tokenCount( tokenCount_ )
-      , pTokens( pTokens_ )
+                                         const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
+      : layout::IndirectCommandsLayoutCreateInfoNVX( pipelineBindPoint_, flags_, tokenCount_, pTokens_ )
     {}
 
     IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
-    {
-      *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this) = rhs;
-    }
+      : layout::IndirectCommandsLayoutCreateInfoNVX( rhs )
+    {}
 
     IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
     {
@@ -34561,13 +39584,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    IndirectCommandsLayoutCreateInfoNVX & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    IndirectCommandsLayoutCreateInfoNVX & setPipelineBindPoint( vk::PipelineBindPoint pipelineBindPoint_ )
     {
       pipelineBindPoint = pipelineBindPoint_;
       return *this;
     }
 
-    IndirectCommandsLayoutCreateInfoNVX & setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
+    IndirectCommandsLayoutCreateInfoNVX & setFlags( vk::IndirectCommandsLayoutUsageFlagsNVX flags_ )
     {
       flags = flags_;
       return *this;
@@ -34579,7 +39602,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    IndirectCommandsLayoutCreateInfoNVX & setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
+    IndirectCommandsLayoutCreateInfoNVX & setPTokens( const vk::IndirectCommandsLayoutTokenNVX* pTokens_ )
     {
       pTokens = pTokens_;
       return *this;
@@ -34611,27 +39634,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineBindPoint pipelineBindPoint;
-    IndirectCommandsLayoutUsageFlagsNVX flags;
-    uint32_t tokenCount;
-    const IndirectCommandsLayoutTokenNVX* pTokens;
+    using layout::IndirectCommandsLayoutCreateInfoNVX::sType;
   };
   static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<IndirectCommandsLayoutCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
 
-  struct InitializePerformanceApiInfoINTEL
+  namespace layout
+  {
+    struct InitializePerformanceApiInfoINTEL
+    {
+    protected:
+      InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr )
+        : pUserData( pUserData_ )
+      {}
+
+      InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(this) = rhs;
+      }
+
+      InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL;
+      const void* pNext = nullptr;
+      void* pUserData;
+    };
+    static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "layout struct and wrapper have different size!" );
+  }
+
+  struct InitializePerformanceApiInfoINTEL : public layout::InitializePerformanceApiInfoINTEL
   {
     InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr )
-      : pUserData( pUserData_ )
+      : layout::InitializePerformanceApiInfoINTEL( pUserData_ )
     {}
 
     InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs )
-    {
-      *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(this) = rhs;
-    }
+      : layout::InitializePerformanceApiInfoINTEL( rhs )
+    {}
 
     InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs )
     {
@@ -34674,22 +39718,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL;
-
-  public:
-    const void* pNext = nullptr;
-    void* pUserData;
+    using layout::InitializePerformanceApiInfoINTEL::sType;
   };
   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!" );
 
   struct InputAttachmentAspectReference
   {
     InputAttachmentAspectReference( uint32_t subpass_ = 0,
                                     uint32_t inputAttachmentIndex_ = 0,
-                                    ImageAspectFlags aspectMask_ = ImageAspectFlags() )
-      : subpass( subpass_ )
-      , inputAttachmentIndex( inputAttachmentIndex_ )
-      , aspectMask( aspectMask_ )
+                                    vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() )
+        : subpass( subpass_ )
+        , inputAttachmentIndex( inputAttachmentIndex_ )
+        , aspectMask( aspectMask_ )
     {}
 
     InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs )
@@ -34715,7 +39756,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    InputAttachmentAspectReference & setAspectMask( ImageAspectFlags aspectMask_ )
+    InputAttachmentAspectReference & setAspectMask( vk::ImageAspectFlags aspectMask_ )
     {
       aspectMask = aspectMask_;
       return *this;
@@ -34743,32 +39784,71 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t subpass;
     uint32_t inputAttachmentIndex;
-    ImageAspectFlags aspectMask;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct InstanceCreateInfo
+    {
+    protected:
+      InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(),
+                          const vk::ApplicationInfo* pApplicationInfo_ = nullptr,
+                          uint32_t enabledLayerCount_ = 0,
+                          const char* const* ppEnabledLayerNames_ = nullptr,
+                          uint32_t enabledExtensionCount_ = 0,
+                          const char* const* ppEnabledExtensionNames_ = nullptr )
+        : flags( flags_ )
+        , pApplicationInfo( pApplicationInfo_ )
+        , enabledLayerCount( enabledLayerCount_ )
+        , ppEnabledLayerNames( ppEnabledLayerNames_ )
+        , enabledExtensionCount( enabledExtensionCount_ )
+        , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+      {}
+
+      InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkInstanceCreateInfo*>(this) = rhs;
+      }
+
+      InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkInstanceCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eInstanceCreateInfo;
+      const void* pNext = nullptr;
+      vk::InstanceCreateFlags flags;
+      const vk::ApplicationInfo* pApplicationInfo;
+      uint32_t enabledLayerCount;
+      const char* const* ppEnabledLayerNames;
+      uint32_t enabledExtensionCount;
+      const char* const* ppEnabledExtensionNames;
+    };
+    static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct InstanceCreateInfo
+  struct InstanceCreateInfo : public layout::InstanceCreateInfo
   {
-    InstanceCreateInfo( InstanceCreateFlags flags_ = InstanceCreateFlags(),
-                        const ApplicationInfo* pApplicationInfo_ = nullptr,
+    InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(),
+                        const vk::ApplicationInfo* pApplicationInfo_ = nullptr,
                         uint32_t enabledLayerCount_ = 0,
                         const char* const* ppEnabledLayerNames_ = nullptr,
                         uint32_t enabledExtensionCount_ = 0,
                         const char* const* ppEnabledExtensionNames_ = nullptr )
-      : flags( flags_ )
-      , pApplicationInfo( pApplicationInfo_ )
-      , enabledLayerCount( enabledLayerCount_ )
-      , ppEnabledLayerNames( ppEnabledLayerNames_ )
-      , enabledExtensionCount( enabledExtensionCount_ )
-      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+      : layout::InstanceCreateInfo( flags_, pApplicationInfo_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_ )
     {}
 
     InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkInstanceCreateInfo*>(this) = rhs;
-    }
+      : layout::InstanceCreateInfo( rhs )
+    {}
 
     InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
     {
@@ -34782,13 +39862,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    InstanceCreateInfo & setFlags( InstanceCreateFlags flags_ )
+    InstanceCreateInfo & setFlags( vk::InstanceCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    InstanceCreateInfo & setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ )
+    InstanceCreateInfo & setPApplicationInfo( const vk::ApplicationInfo* pApplicationInfo_ )
     {
       pApplicationInfo = pApplicationInfo_;
       return *this;
@@ -34846,18 +39926,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eInstanceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    InstanceCreateFlags flags;
-    const ApplicationInfo* pApplicationInfo;
-    uint32_t enabledLayerCount;
-    const char* const* ppEnabledLayerNames;
-    uint32_t enabledExtensionCount;
-    const char* const* ppEnabledExtensionNames;
+    using layout::InstanceCreateInfo::sType;
   };
   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!" );
 
   struct LayerProperties
   {
@@ -34884,26 +39956,58 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     char layerName[VK_MAX_EXTENSION_NAME_SIZE];
     uint32_t specVersion;
     uint32_t implementationVersion;
     char description[VK_MAX_DESCRIPTION_SIZE];
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_MACOS_MVK
-  struct MacOSSurfaceCreateInfoMVK
+
+  namespace layout
+  {
+    struct MacOSSurfaceCreateInfoMVK
+    {
+    protected:
+      MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(),
+                                 const void* pView_ = nullptr )
+        : flags( flags_ )
+        , pView( pView_ )
+      {}
+
+      MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
+      {
+        *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this) = rhs;
+      }
+
+      MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs )
+      {
+        *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
+      const void* pNext = nullptr;
+      vk::MacOSSurfaceCreateFlagsMVK flags;
+      const void* pView;
+    };
+    static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MacOSSurfaceCreateInfoMVK : public layout::MacOSSurfaceCreateInfoMVK
   {
-    MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(),
+    MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(),
                                const void* pView_ = nullptr )
-      : flags( flags_ )
-      , pView( pView_ )
+      : layout::MacOSSurfaceCreateInfoMVK( flags_, pView_ )
     {}
 
     MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
-    {
-      *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this) = rhs;
-    }
+      : layout::MacOSSurfaceCreateInfoMVK( rhs )
+    {}
 
     MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs )
     {
@@ -34917,7 +40021,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MacOSSurfaceCreateInfoMVK & setFlags( MacOSSurfaceCreateFlagsMVK flags_ )
+    MacOSSurfaceCreateInfoMVK & setFlags( vk::MacOSSurfaceCreateFlagsMVK flags_ )
     {
       flags = flags_;
       return *this;
@@ -34953,30 +40057,57 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
-
-  public:
-    const void* pNext = nullptr;
-    MacOSSurfaceCreateFlagsMVK flags;
-    const void* pView;
+    using layout::MacOSSurfaceCreateInfoMVK::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
 
-  struct MappedMemoryRange
+  namespace layout
   {
-    MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(),
-                       DeviceSize offset_ = 0,
-                       DeviceSize size_ = 0 )
-      : memory( memory_ )
-      , offset( offset_ )
-      , size( size_ )
+    struct MappedMemoryRange
+    {
+    protected:
+      MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                         vk::DeviceSize offset_ = 0,
+                         vk::DeviceSize size_ = 0 )
+        : memory( memory_ )
+        , offset( offset_ )
+        , size( size_ )
+      {}
+
+      MappedMemoryRange( VkMappedMemoryRange const & rhs )
+      {
+        *reinterpret_cast<VkMappedMemoryRange*>(this) = rhs;
+      }
+
+      MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
+      {
+        *reinterpret_cast<VkMappedMemoryRange*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMappedMemoryRange;
+      const void* pNext = nullptr;
+      vk::DeviceMemory memory;
+      vk::DeviceSize offset;
+      vk::DeviceSize size;
+    };
+    static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MappedMemoryRange : public layout::MappedMemoryRange
+  {
+    MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                       vk::DeviceSize offset_ = 0,
+                       vk::DeviceSize size_ = 0 )
+      : layout::MappedMemoryRange( memory_, offset_, size_ )
     {}
 
     MappedMemoryRange( VkMappedMemoryRange const & rhs )
-    {
-      *reinterpret_cast<VkMappedMemoryRange*>(this) = rhs;
-    }
+      : layout::MappedMemoryRange( rhs )
+    {}
 
     MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
     {
@@ -34990,19 +40121,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MappedMemoryRange & setMemory( DeviceMemory memory_ )
+    MappedMemoryRange & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    MappedMemoryRange & setOffset( DeviceSize offset_ )
+    MappedMemoryRange & setOffset( vk::DeviceSize offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    MappedMemoryRange & setSize( DeviceSize size_ )
+    MappedMemoryRange & setSize( vk::DeviceSize size_ )
     {
       size = size_;
       return *this;
@@ -35033,28 +40164,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMappedMemoryRange;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-    DeviceSize offset;
-    DeviceSize size;
+    using layout::MappedMemoryRange::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct MemoryAllocateFlagsInfo
+    {
+    protected:
+      MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(),
+                               uint32_t deviceMask_ = 0 )
+        : flags( flags_ )
+        , deviceMask( deviceMask_ )
+      {}
+
+      MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs )
+      {
+        *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this) = rhs;
+      }
+
+      MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs )
+      {
+        *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
+      const void* pNext = nullptr;
+      vk::MemoryAllocateFlags flags;
+      uint32_t deviceMask;
+    };
+    static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct MemoryAllocateFlagsInfo
+  struct MemoryAllocateFlagsInfo : public layout::MemoryAllocateFlagsInfo
   {
-    MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = MemoryAllocateFlags(),
+    MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(),
                              uint32_t deviceMask_ = 0 )
-      : flags( flags_ )
-      , deviceMask( deviceMask_ )
+      : layout::MemoryAllocateFlagsInfo( flags_, deviceMask_ )
     {}
 
     MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs )
-    {
-      *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this) = rhs;
-    }
+      : layout::MemoryAllocateFlagsInfo( rhs )
+    {}
 
     MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs )
     {
@@ -35068,7 +40223,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MemoryAllocateFlagsInfo & setFlags( MemoryAllocateFlags flags_ )
+    MemoryAllocateFlagsInfo & setFlags( vk::MemoryAllocateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -35104,27 +40259,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
-
-  public:
-    const void* pNext = nullptr;
-    MemoryAllocateFlags flags;
-    uint32_t deviceMask;
+    using layout::MemoryAllocateFlagsInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct MemoryAllocateInfo
+    {
+    protected:
+      MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0,
+                          uint32_t memoryTypeIndex_ = 0 )
+        : allocationSize( allocationSize_ )
+        , memoryTypeIndex( memoryTypeIndex_ )
+      {}
+
+      MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkMemoryAllocateInfo*>(this) = rhs;
+      }
+
+      MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkMemoryAllocateInfo*>(this) = rhs;
+        return *this;
+      }
 
-  struct MemoryAllocateInfo
+    public:
+      vk::StructureType sType = StructureType::eMemoryAllocateInfo;
+      const void* pNext = nullptr;
+      vk::DeviceSize allocationSize;
+      uint32_t memoryTypeIndex;
+    };
+    static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MemoryAllocateInfo : public layout::MemoryAllocateInfo
   {
-    MemoryAllocateInfo( DeviceSize allocationSize_ = 0,
+    MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0,
                         uint32_t memoryTypeIndex_ = 0 )
-      : allocationSize( allocationSize_ )
-      , memoryTypeIndex( memoryTypeIndex_ )
+      : layout::MemoryAllocateInfo( allocationSize_, memoryTypeIndex_ )
     {}
 
     MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
-    {
-      *reinterpret_cast<VkMemoryAllocateInfo*>(this) = rhs;
-    }
+      : layout::MemoryAllocateInfo( rhs )
+    {}
 
     MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
     {
@@ -35138,7 +40318,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MemoryAllocateInfo & setAllocationSize( DeviceSize allocationSize_ )
+    MemoryAllocateInfo & setAllocationSize( vk::DeviceSize allocationSize_ )
     {
       allocationSize = allocationSize_;
       return *this;
@@ -35174,27 +40354,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceSize allocationSize;
-    uint32_t memoryTypeIndex;
+    using layout::MemoryAllocateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct MemoryBarrier
+    {
+    protected:
+      MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                     vk::AccessFlags dstAccessMask_ = vk::AccessFlags() )
+        : srcAccessMask( srcAccessMask_ )
+        , dstAccessMask( dstAccessMask_ )
+      {}
 
-  struct MemoryBarrier
+      MemoryBarrier( VkMemoryBarrier const & rhs )
+      {
+        *reinterpret_cast<VkMemoryBarrier*>(this) = rhs;
+      }
+
+      MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
+      {
+        *reinterpret_cast<VkMemoryBarrier*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryBarrier;
+      const void* pNext = nullptr;
+      vk::AccessFlags srcAccessMask;
+      vk::AccessFlags dstAccessMask;
+    };
+    static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MemoryBarrier : public layout::MemoryBarrier
   {
-    MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
-                   AccessFlags dstAccessMask_ = AccessFlags() )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
+    MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                   vk::AccessFlags dstAccessMask_ = vk::AccessFlags() )
+      : layout::MemoryBarrier( srcAccessMask_, dstAccessMask_ )
     {}
 
     MemoryBarrier( VkMemoryBarrier const & rhs )
-    {
-      *reinterpret_cast<VkMemoryBarrier*>(this) = rhs;
-    }
+      : layout::MemoryBarrier( rhs )
+    {}
 
     MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
     {
@@ -35208,13 +40413,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    MemoryBarrier & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
     {
       srcAccessMask = srcAccessMask_;
       return *this;
     }
 
-    MemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+    MemoryBarrier & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
     {
       dstAccessMask = dstAccessMask_;
       return *this;
@@ -35244,27 +40449,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
+    using layout::MemoryBarrier::sType;
   };
   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!" );
 
-  struct MemoryDedicatedAllocateInfo
+  namespace layout
   {
-    MemoryDedicatedAllocateInfo( Image image_ = Image(),
-                                 Buffer buffer_ = Buffer() )
-      : image( image_ )
-      , buffer( buffer_ )
+    struct MemoryDedicatedAllocateInfo
+    {
+    protected:
+      MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(),
+                                   vk::Buffer buffer_ = vk::Buffer() )
+        : image( image_ )
+        , buffer( buffer_ )
+      {}
+
+      MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this) = rhs;
+      }
+
+      MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs )
+      {
+        *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo;
+      const void* pNext = nullptr;
+      vk::Image image;
+      vk::Buffer buffer;
+    };
+    static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MemoryDedicatedAllocateInfo : public layout::MemoryDedicatedAllocateInfo
+  {
+    MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(),
+                                 vk::Buffer buffer_ = vk::Buffer() )
+      : layout::MemoryDedicatedAllocateInfo( image_, buffer_ )
     {}
 
     MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs )
-    {
-      *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this) = rhs;
-    }
+      : layout::MemoryDedicatedAllocateInfo( rhs )
+    {}
 
     MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs )
     {
@@ -35278,13 +40508,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MemoryDedicatedAllocateInfo & setImage( Image image_ )
+    MemoryDedicatedAllocateInfo & setImage( vk::Image image_ )
     {
       image = image_;
       return *this;
     }
 
-    MemoryDedicatedAllocateInfo & setBuffer( Buffer buffer_ )
+    MemoryDedicatedAllocateInfo & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
@@ -35314,16 +40544,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryDedicatedAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    Buffer buffer;
+    using layout::MemoryDedicatedAllocateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct MemoryDedicatedRequirements
+    {
+    protected:
+      MemoryDedicatedRequirements( vk::Bool32 prefersDedicatedAllocation_ = 0,
+                                   vk::Bool32 requiresDedicatedAllocation_ = 0 )
+        : prefersDedicatedAllocation( prefersDedicatedAllocation_ )
+        , requiresDedicatedAllocation( requiresDedicatedAllocation_ )
+      {}
+
+      MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs )
+      {
+        *reinterpret_cast<VkMemoryDedicatedRequirements*>(this) = rhs;
+      }
+
+      MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs )
+      {
+        *reinterpret_cast<VkMemoryDedicatedRequirements*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryDedicatedRequirements;
+      void* pNext = nullptr;
+      vk::Bool32 prefersDedicatedAllocation;
+      vk::Bool32 requiresDedicatedAllocation;
+    };
+    static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "layout struct and wrapper have different size!" );
+  }
 
-  struct MemoryDedicatedRequirements
+  struct MemoryDedicatedRequirements : public layout::MemoryDedicatedRequirements
   {
     operator VkMemoryDedicatedRequirements const&() const
     {
@@ -35349,16 +40606,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryDedicatedRequirements;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 prefersDedicatedAllocation;
-    Bool32 requiresDedicatedAllocation;
+    using layout::MemoryDedicatedRequirements::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct MemoryFdPropertiesKHR
+    {
+    protected:
+      MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = 0 )
+        : memoryTypeBits( memoryTypeBits_ )
+      {}
+
+      MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this) = rhs;
+      }
+
+      MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryFdPropertiesKHR;
+      void* pNext = nullptr;
+      uint32_t memoryTypeBits;
+    };
+    static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct MemoryFdPropertiesKHR
+  struct MemoryFdPropertiesKHR : public layout::MemoryFdPropertiesKHR
   {
     operator VkMemoryFdPropertiesKHR const&() const
     {
@@ -35383,25 +40664,50 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryFdPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
+    using layout::MemoryFdPropertiesKHR::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct MemoryGetAndroidHardwareBufferInfoANDROID
+
+  namespace layout
+  {
+    struct MemoryGetAndroidHardwareBufferInfoANDROID
+    {
+    protected:
+      MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() )
+        : memory( memory_ )
+      {}
+
+      MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
+      {
+        *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this) = rhs;
+      }
+
+      MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
+      {
+        *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
+      const void* pNext = nullptr;
+      vk::DeviceMemory memory;
+    };
+    static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MemoryGetAndroidHardwareBufferInfoANDROID : public layout::MemoryGetAndroidHardwareBufferInfoANDROID
   {
-    MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = DeviceMemory() )
-      : memory( memory_ )
+    MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() )
+      : layout::MemoryGetAndroidHardwareBufferInfoANDROID( memory_ )
     {}
 
     MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
-    {
-      *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this) = rhs;
-    }
+      : layout::MemoryGetAndroidHardwareBufferInfoANDROID( rhs )
+    {}
 
     MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
     {
@@ -35415,7 +40721,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MemoryGetAndroidHardwareBufferInfoANDROID & setMemory( DeviceMemory memory_ )
+    MemoryGetAndroidHardwareBufferInfoANDROID & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
@@ -35444,27 +40750,53 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
+    using layout::MemoryGetAndroidHardwareBufferInfoANDROID::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  struct MemoryGetFdInfoKHR
+  namespace layout
+  {
+    struct MemoryGetFdInfoKHR
+    {
+    protected:
+      MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                          vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+        : memory( memory_ )
+        , handleType( handleType_ )
+      {}
+
+      MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this) = rhs;
+      }
+
+      MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryGetFdInfoKHR;
+      const void* pNext = nullptr;
+      vk::DeviceMemory memory;
+      vk::ExternalMemoryHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MemoryGetFdInfoKHR : public layout::MemoryGetFdInfoKHR
   {
-    MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(),
-                        ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
-      : memory( memory_ )
-      , handleType( handleType_ )
+    MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                        vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+      : layout::MemoryGetFdInfoKHR( memory_, handleType_ )
     {}
 
     MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this) = rhs;
-    }
+      : layout::MemoryGetFdInfoKHR( rhs )
+    {}
 
     MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
     {
@@ -35478,13 +40810,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MemoryGetFdInfoKHR & setMemory( DeviceMemory memory_ )
+    MemoryGetFdInfoKHR & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    MemoryGetFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    MemoryGetFdInfoKHR & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -35514,28 +40846,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-    ExternalMemoryHandleTypeFlagBits handleType;
+    using layout::MemoryGetFdInfoKHR::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct MemoryGetWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct MemoryGetWin32HandleInfoKHR
+    {
+    protected:
+      MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                                   vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+        : memory( memory_ )
+        , handleType( handleType_ )
+      {}
+
+      MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      vk::DeviceMemory memory;
+      vk::ExternalMemoryHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MemoryGetWin32HandleInfoKHR : public layout::MemoryGetWin32HandleInfoKHR
   {
-    MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(),
-                                 ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
-      : memory( memory_ )
-      , handleType( handleType_ )
+    MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+                                 vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+      : layout::MemoryGetWin32HandleInfoKHR( memory_, handleType_ )
     {}
 
     MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::MemoryGetWin32HandleInfoKHR( rhs )
+    {}
 
     MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
     {
@@ -35549,13 +40907,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MemoryGetWin32HandleInfoKHR & setMemory( DeviceMemory memory_ )
+    MemoryGetWin32HandleInfoKHR & setMemory( vk::DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    MemoryGetWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    MemoryGetWin32HandleInfoKHR & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -35585,14 +40943,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-    ExternalMemoryHandleTypeFlagBits handleType;
+    using layout::MemoryGetWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct MemoryHeap
@@ -35618,12 +40972,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DeviceSize size;
-    MemoryHeapFlags flags;
+  public:
+    vk::DeviceSize size;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct MemoryHostPointerPropertiesEXT
+    {
+    protected:
+      MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 )
+        : memoryTypeBits( memoryTypeBits_ )
+      {}
+
+      MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this) = rhs;
+      }
+
+      MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t memoryTypeBits;
+    };
+    static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct MemoryHostPointerPropertiesEXT
+  struct MemoryHostPointerPropertiesEXT : public layout::MemoryHostPointerPropertiesEXT
   {
     operator VkMemoryHostPointerPropertiesEXT const&() const
     {
@@ -35648,24 +41032,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
+    using layout::MemoryHostPointerPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct MemoryPriorityAllocateInfoEXT
+    {
+    protected:
+      MemoryPriorityAllocateInfoEXT( float priority_ = 0 )
+        : priority( priority_ )
+      {}
+
+      MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this) = rhs;
+      }
+
+      MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT;
+      const void* pNext = nullptr;
+      float priority;
+    };
+    static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct MemoryPriorityAllocateInfoEXT
+  struct MemoryPriorityAllocateInfoEXT : public layout::MemoryPriorityAllocateInfoEXT
   {
     MemoryPriorityAllocateInfoEXT( float priority_ = 0 )
-      : priority( priority_ )
+      : layout::MemoryPriorityAllocateInfoEXT( priority_ )
     {}
 
     MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this) = rhs;
-    }
+      : layout::MemoryPriorityAllocateInfoEXT( rhs )
+    {}
 
     MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs )
     {
@@ -35708,13 +41116,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    float priority;
+    using layout::MemoryPriorityAllocateInfoEXT::sType;
   };
   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!" );
 
   struct MemoryRequirements
   {
@@ -35740,13 +41145,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    DeviceSize size;
-    DeviceSize alignment;
+  public:
+    vk::DeviceSize size;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct MemoryRequirements2
+    {
+    protected:
+      MemoryRequirements2( vk::MemoryRequirements memoryRequirements_ = vk::MemoryRequirements() )
+        : memoryRequirements( memoryRequirements_ )
+      {}
+
+      MemoryRequirements2( VkMemoryRequirements2 const & rhs )
+      {
+        *reinterpret_cast<VkMemoryRequirements2*>(this) = rhs;
+      }
 
-  struct MemoryRequirements2
+      MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs )
+      {
+        *reinterpret_cast<VkMemoryRequirements2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryRequirements2;
+      void* pNext = nullptr;
+      vk::MemoryRequirements memoryRequirements;
+    };
+    static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MemoryRequirements2 : public layout::MemoryRequirements2
   {
     operator VkMemoryRequirements2 const&() const
     {
@@ -35771,13 +41206,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryRequirements2;
-
-  public:
-    void* pNext = nullptr;
-    MemoryRequirements memoryRequirements;
+    using layout::MemoryRequirements2::sType;
   };
   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!" );
 
   struct MemoryType
   {
@@ -35802,13 +41234,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    MemoryPropertyFlags propertyFlags;
+  public:
+    vk::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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct MemoryWin32HandlePropertiesKHR
+
+  namespace layout
+  {
+    struct MemoryWin32HandlePropertiesKHR
+    {
+    protected:
+      MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = 0 )
+        : memoryTypeBits( memoryTypeBits_ )
+      {}
+
+      MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this) = rhs;
+      }
+
+      MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
+      void* pNext = nullptr;
+      uint32_t memoryTypeBits;
+    };
+    static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MemoryWin32HandlePropertiesKHR : public layout::MemoryWin32HandlePropertiesKHR
   {
     operator VkMemoryWin32HandlePropertiesKHR const&() const
     {
@@ -35833,28 +41296,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
+    using layout::MemoryWin32HandlePropertiesKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_METAL_EXT
-  struct MetalSurfaceCreateInfoEXT
+
+  namespace layout
+  {
+    struct MetalSurfaceCreateInfoEXT
+    {
+    protected:
+      MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(),
+                                 const CAMetalLayer* pLayer_ = nullptr )
+        : flags( flags_ )
+        , pLayer( pLayer_ )
+      {}
+
+      MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>(this) = rhs;
+      }
+
+      MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::MetalSurfaceCreateFlagsEXT flags;
+      const CAMetalLayer* pLayer;
+    };
+    static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MetalSurfaceCreateInfoEXT : public layout::MetalSurfaceCreateInfoEXT
   {
-    MetalSurfaceCreateInfoEXT( MetalSurfaceCreateFlagsEXT flags_ = MetalSurfaceCreateFlagsEXT(),
+    MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(),
                                const CAMetalLayer* pLayer_ = nullptr )
-      : flags( flags_ )
-      , pLayer( pLayer_ )
+      : layout::MetalSurfaceCreateInfoEXT( flags_, pLayer_ )
     {}
 
     MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::MetalSurfaceCreateInfoEXT( rhs )
+    {}
 
     MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs )
     {
@@ -35868,7 +41358,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    MetalSurfaceCreateInfoEXT & setFlags( MetalSurfaceCreateFlagsEXT flags_ )
+    MetalSurfaceCreateInfoEXT & setFlags( vk::MetalSurfaceCreateFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
@@ -35904,17 +41394,41 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    MetalSurfaceCreateFlagsEXT flags;
-    const CAMetalLayer* pLayer;
+    using layout::MetalSurfaceCreateInfoEXT::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
-  struct MultisamplePropertiesEXT
+  namespace layout
+  {
+    struct MultisamplePropertiesEXT
+    {
+    protected:
+      MultisamplePropertiesEXT( vk::Extent2D maxSampleLocationGridSize_ = vk::Extent2D() )
+        : maxSampleLocationGridSize( maxSampleLocationGridSize_ )
+      {}
+
+      MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkMultisamplePropertiesEXT*>(this) = rhs;
+      }
+
+      MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkMultisamplePropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eMultisamplePropertiesEXT;
+      void* pNext = nullptr;
+      vk::Extent2D maxSampleLocationGridSize;
+    };
+    static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct MultisamplePropertiesEXT : public layout::MultisamplePropertiesEXT
   {
     operator VkMultisamplePropertiesEXT const&() const
     {
@@ -35939,40 +41453,80 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eMultisamplePropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Extent2D maxSampleLocationGridSize;
+    using layout::MultisamplePropertiesEXT::sType;
   };
   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!" );
 
-  struct ObjectTableCreateInfoNVX
+  namespace layout
+  {
+    struct ObjectTableCreateInfoNVX
+    {
+    protected:
+      ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0,
+                                const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
+                                const uint32_t* pObjectEntryCounts_ = nullptr,
+                                const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
+                                uint32_t maxUniformBuffersPerDescriptor_ = 0,
+                                uint32_t maxStorageBuffersPerDescriptor_ = 0,
+                                uint32_t maxStorageImagesPerDescriptor_ = 0,
+                                uint32_t maxSampledImagesPerDescriptor_ = 0,
+                                uint32_t maxPipelineLayouts_ = 0 )
+        : objectCount( objectCount_ )
+        , pObjectEntryTypes( pObjectEntryTypes_ )
+        , pObjectEntryCounts( pObjectEntryCounts_ )
+        , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
+        , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
+        , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
+        , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
+        , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
+        , maxPipelineLayouts( maxPipelineLayouts_ )
+      {}
+
+      ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this) = rhs;
+      }
+
+      ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
+      {
+        *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eObjectTableCreateInfoNVX;
+      const void* pNext = nullptr;
+      uint32_t objectCount;
+      const vk::ObjectEntryTypeNVX* pObjectEntryTypes;
+      const uint32_t* pObjectEntryCounts;
+      const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
+      uint32_t maxUniformBuffersPerDescriptor;
+      uint32_t maxStorageBuffersPerDescriptor;
+      uint32_t maxStorageImagesPerDescriptor;
+      uint32_t maxSampledImagesPerDescriptor;
+      uint32_t maxPipelineLayouts;
+    };
+    static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ObjectTableCreateInfoNVX : public layout::ObjectTableCreateInfoNVX
   {
     ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0,
-                              const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
+                              const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
                               const uint32_t* pObjectEntryCounts_ = nullptr,
-                              const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
+                              const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
                               uint32_t maxUniformBuffersPerDescriptor_ = 0,
                               uint32_t maxStorageBuffersPerDescriptor_ = 0,
                               uint32_t maxStorageImagesPerDescriptor_ = 0,
                               uint32_t maxSampledImagesPerDescriptor_ = 0,
                               uint32_t maxPipelineLayouts_ = 0 )
-      : objectCount( objectCount_ )
-      , pObjectEntryTypes( pObjectEntryTypes_ )
-      , pObjectEntryCounts( pObjectEntryCounts_ )
-      , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
-      , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
-      , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
-      , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
-      , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
-      , maxPipelineLayouts( maxPipelineLayouts_ )
+      : layout::ObjectTableCreateInfoNVX( objectCount_, pObjectEntryTypes_, pObjectEntryCounts_, pObjectEntryUsageFlags_, maxUniformBuffersPerDescriptor_, maxStorageBuffersPerDescriptor_, maxStorageImagesPerDescriptor_, maxSampledImagesPerDescriptor_, maxPipelineLayouts_ )
     {}
 
     ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
-    {
-      *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this) = rhs;
-    }
+      : layout::ObjectTableCreateInfoNVX( rhs )
+    {}
 
     ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
     {
@@ -35992,7 +41546,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ObjectTableCreateInfoNVX & setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
+    ObjectTableCreateInfoNVX & setPObjectEntryTypes( const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ )
     {
       pObjectEntryTypes = pObjectEntryTypes_;
       return *this;
@@ -36004,7 +41558,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ObjectTableCreateInfoNVX & setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
+    ObjectTableCreateInfoNVX & setPObjectEntryUsageFlags( const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
     {
       pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
       return *this;
@@ -36071,28 +41625,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eObjectTableCreateInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t objectCount;
-    const ObjectEntryTypeNVX* pObjectEntryTypes;
-    const uint32_t* pObjectEntryCounts;
-    const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
-    uint32_t maxUniformBuffersPerDescriptor;
-    uint32_t maxStorageBuffersPerDescriptor;
-    uint32_t maxStorageImagesPerDescriptor;
-    uint32_t maxSampledImagesPerDescriptor;
-    uint32_t maxPipelineLayouts;
+    using layout::ObjectTableCreateInfoNVX::sType;
   };
   static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ObjectTableCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
 
   struct ObjectTableEntryNVX
   {
-    ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                         ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
-      : type( type_ )
-      , flags( flags_ )
+    ObjectTableEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+                         vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX() )
+        : type( type_ )
+        , flags( flags_ )
     {}
 
     ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
@@ -36106,13 +41649,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ObjectTableEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    ObjectTableEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
     {
       type = type_;
       return *this;
     }
 
-    ObjectTableEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    ObjectTableEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
     {
       flags = flags_;
       return *this;
@@ -36139,30 +41682,33 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
+  public:
+    vk::ObjectEntryTypeNVX type;
+    vk::ObjectEntryUsageFlagsNVX flags;
   };
   static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ObjectTableEntryNVX>::value, "struct wrapper is not a standard layout!" );
 
   struct ObjectTableDescriptorSetEntryNVX
   {
-    ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                      ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                      PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                      DescriptorSet descriptorSet_ = DescriptorSet() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipelineLayout( pipelineLayout_ )
-      , descriptorSet( descriptorSet_ )
+    ObjectTableDescriptorSetEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+                                      vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+                                      vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+                                      vk::DescriptorSet descriptorSet_ = vk::DescriptorSet() )
+        : type( type_ )
+        , flags( flags_ )
+        , pipelineLayout( pipelineLayout_ )
+        , descriptorSet( descriptorSet_ )
     {}
 
     explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                               PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                               DescriptorSet descriptorSet_ = DescriptorSet() )
+                                               vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+                                               vk::DescriptorSet descriptorSet_ = vk::DescriptorSet() )
       : type( objectTableEntryNVX.type )
       , flags( objectTableEntryNVX.flags )
       , pipelineLayout( pipelineLayout_ )
       , descriptorSet( descriptorSet_ )
+
     {}
 
     ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
@@ -36176,25 +41722,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ObjectTableDescriptorSetEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    ObjectTableDescriptorSetEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
     {
       type = type_;
       return *this;
     }
 
-    ObjectTableDescriptorSetEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    ObjectTableDescriptorSetEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ObjectTableDescriptorSetEntryNVX & setPipelineLayout( PipelineLayout pipelineLayout_ )
+    ObjectTableDescriptorSetEntryNVX & setPipelineLayout( vk::PipelineLayout pipelineLayout_ )
     {
       pipelineLayout = pipelineLayout_;
       return *this;
     }
 
-    ObjectTableDescriptorSetEntryNVX & setDescriptorSet( DescriptorSet descriptorSet_ )
+    ObjectTableDescriptorSetEntryNVX & setDescriptorSet( vk::DescriptorSet descriptorSet_ )
     {
       descriptorSet = descriptorSet_;
       return *this;
@@ -36223,32 +41769,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    PipelineLayout pipelineLayout;
-    DescriptorSet descriptorSet;
+  public:
+    vk::ObjectEntryTypeNVX type;
+    vk::ObjectEntryUsageFlagsNVX flags;
+    vk::PipelineLayout pipelineLayout;
+    vk::DescriptorSet descriptorSet;
   };
   static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ObjectTableDescriptorSetEntryNVX>::value, "struct wrapper is not a standard layout!" );
 
   struct ObjectTableIndexBufferEntryNVX
   {
-    ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                    ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                    Buffer buffer_ = Buffer(),
-                                    IndexType indexType_ = IndexType::eUint16 )
-      : type( type_ )
-      , flags( flags_ )
-      , buffer( buffer_ )
-      , indexType( indexType_ )
+    ObjectTableIndexBufferEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+                                    vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+                                    vk::Buffer buffer_ = vk::Buffer(),
+                                    vk::IndexType indexType_ = vk::IndexType::eUint16 )
+        : type( type_ )
+        , flags( flags_ )
+        , buffer( buffer_ )
+        , indexType( indexType_ )
     {}
 
     explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                             Buffer buffer_ = Buffer(),
-                                             IndexType indexType_ = IndexType::eUint16 )
+                                             vk::Buffer buffer_ = vk::Buffer(),
+                                             vk::IndexType indexType_ = vk::IndexType::eUint16 )
       : type( objectTableEntryNVX.type )
       , flags( objectTableEntryNVX.flags )
       , buffer( buffer_ )
       , indexType( indexType_ )
+
     {}
 
     ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
@@ -36262,25 +41811,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ObjectTableIndexBufferEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    ObjectTableIndexBufferEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
     {
       type = type_;
       return *this;
     }
 
-    ObjectTableIndexBufferEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    ObjectTableIndexBufferEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ObjectTableIndexBufferEntryNVX & setBuffer( Buffer buffer_ )
+    ObjectTableIndexBufferEntryNVX & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
     }
 
-    ObjectTableIndexBufferEntryNVX & setIndexType( IndexType indexType_ )
+    ObjectTableIndexBufferEntryNVX & setIndexType( vk::IndexType indexType_ )
     {
       indexType = indexType_;
       return *this;
@@ -36309,28 +41858,31 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Buffer buffer;
-    IndexType indexType;
+  public:
+    vk::ObjectEntryTypeNVX type;
+    vk::ObjectEntryUsageFlagsNVX flags;
+    vk::Buffer buffer;
+    vk::IndexType indexType;
   };
   static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ObjectTableIndexBufferEntryNVX>::value, "struct wrapper is not a standard layout!" );
 
   struct ObjectTablePipelineEntryNVX
   {
-    ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                 ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                 Pipeline pipeline_ = Pipeline() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipeline( pipeline_ )
+    ObjectTablePipelineEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+                                 vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+                                 vk::Pipeline pipeline_ = vk::Pipeline() )
+        : type( type_ )
+        , flags( flags_ )
+        , pipeline( pipeline_ )
     {}
 
     explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                          Pipeline pipeline_ = Pipeline() )
+                                          vk::Pipeline pipeline_ = vk::Pipeline() )
       : type( objectTableEntryNVX.type )
       , flags( objectTableEntryNVX.flags )
       , pipeline( pipeline_ )
+
     {}
 
     ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
@@ -36344,19 +41896,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ObjectTablePipelineEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    ObjectTablePipelineEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
     {
       type = type_;
       return *this;
     }
 
-    ObjectTablePipelineEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    ObjectTablePipelineEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ObjectTablePipelineEntryNVX & setPipeline( Pipeline pipeline_ )
+    ObjectTablePipelineEntryNVX & setPipeline( vk::Pipeline pipeline_ )
     {
       pipeline = pipeline_;
       return *this;
@@ -36384,31 +41936,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Pipeline pipeline;
+  public:
+    vk::ObjectEntryTypeNVX type;
+    vk::ObjectEntryUsageFlagsNVX flags;
+    vk::Pipeline pipeline;
   };
   static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ObjectTablePipelineEntryNVX>::value, "struct wrapper is not a standard layout!" );
 
   struct ObjectTablePushConstantEntryNVX
   {
-    ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                     ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                     PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                     ShaderStageFlags stageFlags_ = ShaderStageFlags() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipelineLayout( pipelineLayout_ )
-      , stageFlags( stageFlags_ )
+    ObjectTablePushConstantEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+                                     vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+                                     vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+                                     vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags() )
+        : type( type_ )
+        , flags( flags_ )
+        , pipelineLayout( pipelineLayout_ )
+        , stageFlags( stageFlags_ )
     {}
 
     explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                              PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                              ShaderStageFlags stageFlags_ = ShaderStageFlags() )
+                                              vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+                                              vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags() )
       : type( objectTableEntryNVX.type )
       , flags( objectTableEntryNVX.flags )
       , pipelineLayout( pipelineLayout_ )
       , stageFlags( stageFlags_ )
+
     {}
 
     ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
@@ -36422,25 +41977,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ObjectTablePushConstantEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    ObjectTablePushConstantEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
     {
       type = type_;
       return *this;
     }
 
-    ObjectTablePushConstantEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    ObjectTablePushConstantEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ObjectTablePushConstantEntryNVX & setPipelineLayout( PipelineLayout pipelineLayout_ )
+    ObjectTablePushConstantEntryNVX & setPipelineLayout( vk::PipelineLayout pipelineLayout_ )
     {
       pipelineLayout = pipelineLayout_;
       return *this;
     }
 
-    ObjectTablePushConstantEntryNVX & setStageFlags( ShaderStageFlags stageFlags_ )
+    ObjectTablePushConstantEntryNVX & setStageFlags( vk::ShaderStageFlags stageFlags_ )
     {
       stageFlags = stageFlags_;
       return *this;
@@ -36469,28 +42024,31 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    PipelineLayout pipelineLayout;
-    ShaderStageFlags stageFlags;
+  public:
+    vk::ObjectEntryTypeNVX type;
+    vk::ObjectEntryUsageFlagsNVX flags;
+    vk::PipelineLayout pipelineLayout;
+    vk::ShaderStageFlags stageFlags;
   };
   static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ObjectTablePushConstantEntryNVX>::value, "struct wrapper is not a standard layout!" );
 
   struct ObjectTableVertexBufferEntryNVX
   {
-    ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                     ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                     Buffer buffer_ = Buffer() )
-      : type( type_ )
-      , flags( flags_ )
-      , buffer( buffer_ )
+    ObjectTableVertexBufferEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+                                     vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+                                     vk::Buffer buffer_ = vk::Buffer() )
+        : type( type_ )
+        , flags( flags_ )
+        , buffer( buffer_ )
     {}
 
     explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                              Buffer buffer_ = Buffer() )
+                                              vk::Buffer buffer_ = vk::Buffer() )
       : type( objectTableEntryNVX.type )
       , flags( objectTableEntryNVX.flags )
       , buffer( buffer_ )
+
     {}
 
     ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
@@ -36504,19 +42062,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ObjectTableVertexBufferEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    ObjectTableVertexBufferEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
     {
       type = type_;
       return *this;
     }
 
-    ObjectTableVertexBufferEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    ObjectTableVertexBufferEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ObjectTableVertexBufferEntryNVX & setBuffer( Buffer buffer_ )
+    ObjectTableVertexBufferEntryNVX & setBuffer( vk::Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
@@ -36544,11 +42102,13 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Buffer buffer;
+  public:
+    vk::ObjectEntryTypeNVX type;
+    vk::ObjectEntryUsageFlagsNVX flags;
+    vk::Buffer buffer;
   };
   static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<ObjectTableVertexBufferEntryNVX>::value, "struct wrapper is not a standard layout!" );
 
   struct PastPresentationTimingGOOGLE
   {
@@ -36576,6 +42136,7 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t presentID;
     uint64_t desiredPresentTime;
     uint64_t actualPresentTime;
@@ -36583,17 +42144,45 @@ namespace VULKAN_HPP_NAMESPACE
     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!" );
+
+  namespace layout
+  {
+    struct PerformanceConfigurationAcquireInfoINTEL
+    {
+    protected:
+      PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated )
+        : type( type_ )
+      {}
+
+      PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this) = rhs;
+      }
+
+      PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this) = rhs;
+        return *this;
+      }
 
-  struct PerformanceConfigurationAcquireInfoINTEL
+    public:
+      vk::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL;
+      const void* pNext = nullptr;
+      vk::PerformanceConfigurationTypeINTEL type;
+    };
+    static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PerformanceConfigurationAcquireInfoINTEL : public layout::PerformanceConfigurationAcquireInfoINTEL
   {
-    PerformanceConfigurationAcquireInfoINTEL( PerformanceConfigurationTypeINTEL type_ = PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated )
-      : type( type_ )
+    PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated )
+      : layout::PerformanceConfigurationAcquireInfoINTEL( type_ )
     {}
 
     PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs )
-    {
-      *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this) = rhs;
-    }
+      : layout::PerformanceConfigurationAcquireInfoINTEL( rhs )
+    {}
 
     PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs )
     {
@@ -36607,7 +42196,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PerformanceConfigurationAcquireInfoINTEL & setType( PerformanceConfigurationTypeINTEL type_ )
+    PerformanceConfigurationAcquireInfoINTEL & setType( vk::PerformanceConfigurationTypeINTEL type_ )
     {
       type = type_;
       return *this;
@@ -36636,24 +42225,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL;
-
-  public:
-    const void* pNext = nullptr;
-    PerformanceConfigurationTypeINTEL type;
+    using layout::PerformanceConfigurationAcquireInfoINTEL::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PerformanceMarkerInfoINTEL
+    {
+    protected:
+      PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 )
+        : marker( marker_ )
+      {}
 
-  struct PerformanceMarkerInfoINTEL
+      PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this) = rhs;
+      }
+
+      PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL;
+      const void* pNext = nullptr;
+      uint64_t marker;
+    };
+    static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PerformanceMarkerInfoINTEL : public layout::PerformanceMarkerInfoINTEL
   {
     PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 )
-      : marker( marker_ )
+      : layout::PerformanceMarkerInfoINTEL( marker_ )
     {}
 
     PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs )
-    {
-      *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this) = rhs;
-    }
+      : layout::PerformanceMarkerInfoINTEL( rhs )
+    {}
 
     PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs )
     {
@@ -36696,28 +42309,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePerformanceMarkerInfoINTEL;
-
-  public:
-    const void* pNext = nullptr;
-    uint64_t marker;
+    using layout::PerformanceMarkerInfoINTEL::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PerformanceOverrideInfoINTEL
+    {
+    protected:
+      PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware,
+                                    vk::Bool32 enable_ = 0,
+                                    uint64_t parameter_ = 0 )
+        : type( type_ )
+        , enable( enable_ )
+        , parameter( parameter_ )
+      {}
 
-  struct PerformanceOverrideInfoINTEL
+      PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(this) = rhs;
+      }
+
+      PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL;
+      const void* pNext = nullptr;
+      vk::PerformanceOverrideTypeINTEL type;
+      vk::Bool32 enable;
+      uint64_t parameter;
+    };
+    static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PerformanceOverrideInfoINTEL : public layout::PerformanceOverrideInfoINTEL
   {
-    PerformanceOverrideInfoINTEL( PerformanceOverrideTypeINTEL type_ = PerformanceOverrideTypeINTEL::eNullHardware,
-                                  Bool32 enable_ = 0,
+    PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware,
+                                  vk::Bool32 enable_ = 0,
                                   uint64_t parameter_ = 0 )
-      : type( type_ )
-      , enable( enable_ )
-      , parameter( parameter_ )
+      : layout::PerformanceOverrideInfoINTEL( type_, enable_, parameter_ )
     {}
 
     PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs )
-    {
-      *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(this) = rhs;
-    }
+      : layout::PerformanceOverrideInfoINTEL( rhs )
+    {}
 
     PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs )
     {
@@ -36731,13 +42372,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PerformanceOverrideInfoINTEL & setType( PerformanceOverrideTypeINTEL type_ )
+    PerformanceOverrideInfoINTEL & setType( vk::PerformanceOverrideTypeINTEL type_ )
     {
       type = type_;
       return *this;
     }
 
-    PerformanceOverrideInfoINTEL & setEnable( Bool32 enable_ )
+    PerformanceOverrideInfoINTEL & setEnable( vk::Bool32 enable_ )
     {
       enable = enable_;
       return *this;
@@ -36774,26 +42415,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePerformanceOverrideInfoINTEL;
-
-  public:
-    const void* pNext = nullptr;
-    PerformanceOverrideTypeINTEL type;
-    Bool32 enable;
-    uint64_t parameter;
+    using layout::PerformanceOverrideInfoINTEL::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PerformanceStreamMarkerInfoINTEL
+    {
+    protected:
+      PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 )
+        : marker( marker_ )
+      {}
+
+      PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
+      }
+
+      PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL;
+      const void* pNext = nullptr;
+      uint32_t marker;
+    };
+    static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PerformanceStreamMarkerInfoINTEL
+  struct PerformanceStreamMarkerInfoINTEL : public layout::PerformanceStreamMarkerInfoINTEL
   {
     PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 )
-      : marker( marker_ )
+      : layout::PerformanceStreamMarkerInfoINTEL( marker_ )
     {}
 
     PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs )
-    {
-      *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
-    }
+      : layout::PerformanceStreamMarkerInfoINTEL( rhs )
+    {}
 
     PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs )
     {
@@ -36836,13 +42499,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t marker;
+    using layout::PerformanceStreamMarkerInfoINTEL::sType;
   };
   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!" );
 
   union PerformanceValueDataINTEL
   {
@@ -36866,7 +42526,6 @@ namespace VULKAN_HPP_NAMESPACE
       valueString = valueString_;
     }
 
-
     PerformanceValueDataINTEL & setValue32( uint32_t value32_ )
     {
       value32 = value32_;
@@ -36885,7 +42544,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PerformanceValueDataINTEL & setValueBool( Bool32 valueBool_ )
+    PerformanceValueDataINTEL & setValueBool( vk::Bool32 valueBool_ )
     {
       valueBool = valueBool_;
       return *this;
@@ -36910,7 +42569,7 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t value32;
     uint64_t value64;
     float valueFloat;
-    Bool32 valueBool;
+    vk::Bool32 valueBool;
     const char* valueString;
 #else
     uint32_t value32;
@@ -36923,10 +42582,10 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PerformanceValueINTEL
   {
-    PerformanceValueINTEL( PerformanceValueTypeINTEL type_ = PerformanceValueTypeINTEL::eUint32,
-                           PerformanceValueDataINTEL data_ = PerformanceValueDataINTEL() )
-      : type( type_ )
-      , data( data_ )
+    PerformanceValueINTEL( vk::PerformanceValueTypeINTEL type_ = vk::PerformanceValueTypeINTEL::eUint32,
+                           vk::PerformanceValueDataINTEL data_ = vk::PerformanceValueDataINTEL() )
+        : type( type_ )
+        , data( data_ )
     {}
 
     PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs )
@@ -36940,13 +42599,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PerformanceValueINTEL & setType( PerformanceValueTypeINTEL type_ )
+    PerformanceValueINTEL & setType( vk::PerformanceValueTypeINTEL type_ )
     {
       type = type_;
       return *this;
     }
 
-    PerformanceValueINTEL & setData( PerformanceValueDataINTEL data_ )
+    PerformanceValueINTEL & setData( vk::PerformanceValueDataINTEL data_ )
     {
       data = data_;
       return *this;
@@ -36962,27 +42621,62 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceValueINTEL*>( this );
     }
 
-    PerformanceValueTypeINTEL type;
-    PerformanceValueDataINTEL data;
+  public:
+    vk::PerformanceValueTypeINTEL type;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct PhysicalDevice16BitStorageFeatures
+    {
+    protected:
+      PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0,
+                                          vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
+                                          vk::Bool32 storagePushConstant16_ = 0,
+                                          vk::Bool32 storageInputOutput16_ = 0 )
+        : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
+        , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
+        , storagePushConstant16( storagePushConstant16_ )
+        , storageInputOutput16( storageInputOutput16_ )
+      {}
+
+      PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this) = rhs;
+      }
 
-  struct PhysicalDevice16BitStorageFeatures
+      PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures;
+      void* pNext = nullptr;
+      vk::Bool32 storageBuffer16BitAccess;
+      vk::Bool32 uniformAndStorageBuffer16BitAccess;
+      vk::Bool32 storagePushConstant16;
+      vk::Bool32 storageInputOutput16;
+    };
+    static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDevice16BitStorageFeatures : public layout::PhysicalDevice16BitStorageFeatures
   {
-    PhysicalDevice16BitStorageFeatures( Bool32 storageBuffer16BitAccess_ = 0,
-                                        Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
-                                        Bool32 storagePushConstant16_ = 0,
-                                        Bool32 storageInputOutput16_ = 0 )
-      : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
-      , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
-      , storagePushConstant16( storagePushConstant16_ )
-      , storageInputOutput16( storageInputOutput16_ )
+    PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0,
+                                        vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
+                                        vk::Bool32 storagePushConstant16_ = 0,
+                                        vk::Bool32 storageInputOutput16_ = 0 )
+      : layout::PhysicalDevice16BitStorageFeatures( storageBuffer16BitAccess_, uniformAndStorageBuffer16BitAccess_, storagePushConstant16_, storageInputOutput16_ )
     {}
 
     PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this) = rhs;
-    }
+      : layout::PhysicalDevice16BitStorageFeatures( rhs )
+    {}
 
     PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs )
     {
@@ -36996,25 +42690,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDevice16BitStorageFeatures & setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ )
+    PhysicalDevice16BitStorageFeatures & setStorageBuffer16BitAccess( vk::Bool32 storageBuffer16BitAccess_ )
     {
       storageBuffer16BitAccess = storageBuffer16BitAccess_;
       return *this;
     }
 
-    PhysicalDevice16BitStorageFeatures & setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ )
+    PhysicalDevice16BitStorageFeatures & setUniformAndStorageBuffer16BitAccess( vk::Bool32 uniformAndStorageBuffer16BitAccess_ )
     {
       uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_;
       return *this;
     }
 
-    PhysicalDevice16BitStorageFeatures & setStoragePushConstant16( Bool32 storagePushConstant16_ )
+    PhysicalDevice16BitStorageFeatures & setStoragePushConstant16( vk::Bool32 storagePushConstant16_ )
     {
       storagePushConstant16 = storagePushConstant16_;
       return *this;
     }
 
-    PhysicalDevice16BitStorageFeatures & setStorageInputOutput16( Bool32 storageInputOutput16_ )
+    PhysicalDevice16BitStorageFeatures & setStorageInputOutput16( vk::Bool32 storageInputOutput16_ )
     {
       storageInputOutput16 = storageInputOutput16_;
       return *this;
@@ -37046,31 +42740,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 storageBuffer16BitAccess;
-    Bool32 uniformAndStorageBuffer16BitAccess;
-    Bool32 storagePushConstant16;
-    Bool32 storageInputOutput16;
+    using layout::PhysicalDevice16BitStorageFeatures::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDevice8BitStorageFeaturesKHR
+    {
+    protected:
+      PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0,
+                                            vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
+                                            vk::Bool32 storagePushConstant8_ = 0 )
+        : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
+        , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
+        , storagePushConstant8( storagePushConstant8_ )
+      {}
 
-  struct PhysicalDevice8BitStorageFeaturesKHR
+      PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this) = rhs;
+      }
+
+      PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR;
+      void* pNext = nullptr;
+      vk::Bool32 storageBuffer8BitAccess;
+      vk::Bool32 uniformAndStorageBuffer8BitAccess;
+      vk::Bool32 storagePushConstant8;
+    };
+    static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDevice8BitStorageFeaturesKHR : public layout::PhysicalDevice8BitStorageFeaturesKHR
   {
-    PhysicalDevice8BitStorageFeaturesKHR( Bool32 storageBuffer8BitAccess_ = 0,
-                                          Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
-                                          Bool32 storagePushConstant8_ = 0 )
-      : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
-      , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
-      , storagePushConstant8( storagePushConstant8_ )
+    PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0,
+                                          vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
+                                          vk::Bool32 storagePushConstant8_ = 0 )
+      : layout::PhysicalDevice8BitStorageFeaturesKHR( storageBuffer8BitAccess_, uniformAndStorageBuffer8BitAccess_, storagePushConstant8_ )
     {}
 
     PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this) = rhs;
-    }
+      : layout::PhysicalDevice8BitStorageFeaturesKHR( rhs )
+    {}
 
     PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
     {
@@ -37084,19 +42803,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDevice8BitStorageFeaturesKHR & setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ )
+    PhysicalDevice8BitStorageFeaturesKHR & setStorageBuffer8BitAccess( vk::Bool32 storageBuffer8BitAccess_ )
     {
       storageBuffer8BitAccess = storageBuffer8BitAccess_;
       return *this;
     }
 
-    PhysicalDevice8BitStorageFeaturesKHR & setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ )
+    PhysicalDevice8BitStorageFeaturesKHR & setUniformAndStorageBuffer8BitAccess( vk::Bool32 uniformAndStorageBuffer8BitAccess_ )
     {
       uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_;
       return *this;
     }
 
-    PhysicalDevice8BitStorageFeaturesKHR & setStoragePushConstant8( Bool32 storagePushConstant8_ )
+    PhysicalDevice8BitStorageFeaturesKHR & setStoragePushConstant8( vk::Bool32 storagePushConstant8_ )
     {
       storagePushConstant8 = storagePushConstant8_;
       return *this;
@@ -37127,26 +42846,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 storageBuffer8BitAccess;
-    Bool32 uniformAndStorageBuffer8BitAccess;
-    Bool32 storagePushConstant8;
+    using layout::PhysicalDevice8BitStorageFeaturesKHR::sType;
   };
   static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDevice8BitStorageFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  struct PhysicalDeviceASTCDecodeFeaturesEXT
+  namespace layout
   {
-    PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = 0 )
-      : decodeModeSharedExponent( decodeModeSharedExponent_ )
+    struct PhysicalDeviceASTCDecodeFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 )
+        : decodeModeSharedExponent( decodeModeSharedExponent_ )
+      {}
+
+      PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 decodeModeSharedExponent;
+    };
+    static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceASTCDecodeFeaturesEXT : public layout::PhysicalDeviceASTCDecodeFeaturesEXT
+  {
+    PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 )
+      : layout::PhysicalDeviceASTCDecodeFeaturesEXT( decodeModeSharedExponent_ )
     {}
 
     PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceASTCDecodeFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
     {
@@ -37160,7 +42901,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ )
+    PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent( vk::Bool32 decodeModeSharedExponent_ )
     {
       decodeModeSharedExponent = decodeModeSharedExponent_;
       return *this;
@@ -37189,24 +42930,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 decodeModeSharedExponent;
+    using layout::PhysicalDeviceASTCDecodeFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 )
+        : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
+      {}
+
+      PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 advancedBlendCoherentOperations;
+    };
+    static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
+  struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT : public layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT
   {
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 )
-      : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
+    PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 )
+      : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( advancedBlendCoherentOperations_ )
     {}
 
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
     {
@@ -37220,7 +42985,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ )
+    PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setAdvancedBlendCoherentOperations( vk::Bool32 advancedBlendCoherentOperations_ )
     {
       advancedBlendCoherentOperations = advancedBlendCoherentOperations_;
       return *this;
@@ -37249,15 +43014,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 advancedBlendCoherentOperations;
+    using layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::sType;
   };
   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!" );
 
-  struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
+  namespace layout
+  {
+    struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceBlendOperationAdvancedPropertiesEXT( uint32_t advancedBlendMaxColorAttachments_ = 0,
+                                                         vk::Bool32 advancedBlendIndependentBlend_ = 0,
+                                                         vk::Bool32 advancedBlendNonPremultipliedSrcColor_ = 0,
+                                                         vk::Bool32 advancedBlendNonPremultipliedDstColor_ = 0,
+                                                         vk::Bool32 advancedBlendCorrelatedOverlap_ = 0,
+                                                         vk::Bool32 advancedBlendAllOperations_ = 0 )
+        : advancedBlendMaxColorAttachments( advancedBlendMaxColorAttachments_ )
+        , advancedBlendIndependentBlend( advancedBlendIndependentBlend_ )
+        , advancedBlendNonPremultipliedSrcColor( advancedBlendNonPremultipliedSrcColor_ )
+        , advancedBlendNonPremultipliedDstColor( advancedBlendNonPremultipliedDstColor_ )
+        , advancedBlendCorrelatedOverlap( advancedBlendCorrelatedOverlap_ )
+        , advancedBlendAllOperations( advancedBlendAllOperations_ )
+      {}
+
+      PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t advancedBlendMaxColorAttachments;
+      vk::Bool32 advancedBlendIndependentBlend;
+      vk::Bool32 advancedBlendNonPremultipliedSrcColor;
+      vk::Bool32 advancedBlendNonPremultipliedDstColor;
+      vk::Bool32 advancedBlendCorrelatedOverlap;
+      vk::Bool32 advancedBlendAllOperations;
+    };
+    static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT : public layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT
   {
     operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const&() const
     {
@@ -37287,33 +43092,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t advancedBlendMaxColorAttachments;
-    Bool32 advancedBlendIndependentBlend;
-    Bool32 advancedBlendNonPremultipliedSrcColor;
-    Bool32 advancedBlendNonPremultipliedDstColor;
-    Bool32 advancedBlendCorrelatedOverlap;
-    Bool32 advancedBlendAllOperations;
+    using layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::sType;
   };
   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!" );
 
-  struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
+  namespace layout
   {
-    PhysicalDeviceBufferDeviceAddressFeaturesEXT( Bool32 bufferDeviceAddress_ = 0,
-                                                  Bool32 bufferDeviceAddressCaptureReplay_ = 0,
-                                                  Bool32 bufferDeviceAddressMultiDevice_ = 0 )
-      : bufferDeviceAddress( bufferDeviceAddress_ )
-      , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ )
-      , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
+    struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0,
+                                                    vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0,
+                                                    vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 )
+        : bufferDeviceAddress( bufferDeviceAddress_ )
+        , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ )
+        , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
+      {}
+
+      PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 bufferDeviceAddress;
+      vk::Bool32 bufferDeviceAddressCaptureReplay;
+      vk::Bool32 bufferDeviceAddressMultiDevice;
+    };
+    static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceBufferDeviceAddressFeaturesEXT : public layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT
+  {
+    PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0,
+                                                  vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0,
+                                                  vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 )
+      : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( bufferDeviceAddress_, bufferDeviceAddressCaptureReplay_, bufferDeviceAddressMultiDevice_ )
     {}
 
     PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs )
     {
@@ -37327,19 +43155,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ )
+    PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddress( vk::Bool32 bufferDeviceAddress_ )
     {
       bufferDeviceAddress = bufferDeviceAddress_;
       return *this;
     }
 
-    PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ )
+    PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( vk::Bool32 bufferDeviceAddressCaptureReplay_ )
     {
       bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_;
       return *this;
     }
 
-    PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ )
+    PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( vk::Bool32 bufferDeviceAddressMultiDevice_ )
     {
       bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_;
       return *this;
@@ -37370,29 +43198,137 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 bufferDeviceAddress;
-    Bool32 bufferDeviceAddressCaptureReplay;
-    Bool32 bufferDeviceAddressMultiDevice;
+    using layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::sType;
   };
   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!" );
 
-  struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
+  namespace layout
   {
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV( Bool32 computeDerivativeGroupQuads_ = 0,
-                                                      Bool32 computeDerivativeGroupLinear_ = 0 )
-      : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
-      , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
+    struct PhysicalDeviceCoherentMemoryFeaturesAMD
+    {
+    protected:
+      PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 )
+        : deviceCoherentMemory( deviceCoherentMemory_ )
+      {}
+
+      PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this) = rhs;
+      }
+
+      PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD;
+      void* pNext = nullptr;
+      vk::Bool32 deviceCoherentMemory;
+    };
+    static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceCoherentMemoryFeaturesAMD : public layout::PhysicalDeviceCoherentMemoryFeaturesAMD
+  {
+    PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 )
+      : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( deviceCoherentMemory_ )
     {}
 
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
+    PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs )
+      : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( rhs )
+    {}
+
+    PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs )
     {
-      *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this) = rhs;
+      *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this) = rhs;
+      return *this;
+    }
+
+    PhysicalDeviceCoherentMemoryFeaturesAMD & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceCoherentMemoryFeaturesAMD & setDeviceCoherentMemory( vk::Bool32 deviceCoherentMemory_ )
+    {
+      deviceCoherentMemory = deviceCoherentMemory_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>( this );
+    }
+
+    operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>( this );
+    }
+
+    bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( deviceCoherentMemory == rhs.deviceCoherentMemory );
     }
 
+    bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PhysicalDeviceCoherentMemoryFeaturesAMD::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
+    {
+    protected:
+      PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0,
+                                                        vk::Bool32 computeDerivativeGroupLinear_ = 0 )
+        : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
+        , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
+      {}
+
+      PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 computeDerivativeGroupQuads;
+      vk::Bool32 computeDerivativeGroupLinear;
+    };
+    static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceComputeShaderDerivativesFeaturesNV : public layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV
+  {
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0,
+                                                      vk::Bool32 computeDerivativeGroupLinear_ = 0 )
+      : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( computeDerivativeGroupQuads_, computeDerivativeGroupLinear_ )
+    {}
+
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
+      : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( rhs )
+    {}
+
     PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
     {
       *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this) = rhs;
@@ -37405,13 +43341,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ )
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupQuads( vk::Bool32 computeDerivativeGroupQuads_ )
     {
       computeDerivativeGroupQuads = computeDerivativeGroupQuads_;
       return *this;
     }
 
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ )
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupLinear( vk::Bool32 computeDerivativeGroupLinear_ )
     {
       computeDerivativeGroupLinear = computeDerivativeGroupLinear_;
       return *this;
@@ -37441,27 +43377,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 computeDerivativeGroupQuads;
-    Bool32 computeDerivativeGroupLinear;
+    using layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceConditionalRenderingFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0,
+                                                     vk::Bool32 inheritedConditionalRendering_ = 0 )
+        : conditionalRendering( conditionalRendering_ )
+        , inheritedConditionalRendering( inheritedConditionalRendering_ )
+      {}
 
-  struct PhysicalDeviceConditionalRenderingFeaturesEXT
+      PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 conditionalRendering;
+      vk::Bool32 inheritedConditionalRendering;
+    };
+    static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceConditionalRenderingFeaturesEXT : public layout::PhysicalDeviceConditionalRenderingFeaturesEXT
   {
-    PhysicalDeviceConditionalRenderingFeaturesEXT( Bool32 conditionalRendering_ = 0,
-                                                   Bool32 inheritedConditionalRendering_ = 0 )
-      : conditionalRendering( conditionalRendering_ )
-      , inheritedConditionalRendering( inheritedConditionalRendering_ )
+    PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0,
+                                                   vk::Bool32 inheritedConditionalRendering_ = 0 )
+      : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( conditionalRendering_, inheritedConditionalRendering_ )
     {}
 
     PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
     {
@@ -37475,13 +43436,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering( Bool32 conditionalRendering_ )
+    PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering( vk::Bool32 conditionalRendering_ )
     {
       conditionalRendering = conditionalRendering_;
       return *this;
     }
 
-    PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ )
+    PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering( vk::Bool32 inheritedConditionalRendering_ )
     {
       inheritedConditionalRendering = inheritedConditionalRendering_;
       return *this;
@@ -37511,16 +43472,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 conditionalRendering;
-    Bool32 inheritedConditionalRendering;
+    using layout::PhysicalDeviceConditionalRenderingFeaturesEXT::sType;
   };
   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!" );
 
-  struct PhysicalDeviceConservativeRasterizationPropertiesEXT
+  namespace layout
+  {
+    struct PhysicalDeviceConservativeRasterizationPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = 0,
+                                                            float maxExtraPrimitiveOverestimationSize_ = 0,
+                                                            float extraPrimitiveOverestimationSizeGranularity_ = 0,
+                                                            vk::Bool32 primitiveUnderestimation_ = 0,
+                                                            vk::Bool32 conservativePointAndLineRasterization_ = 0,
+                                                            vk::Bool32 degenerateTrianglesRasterized_ = 0,
+                                                            vk::Bool32 degenerateLinesRasterized_ = 0,
+                                                            vk::Bool32 fullyCoveredFragmentShaderInputVariable_ = 0,
+                                                            vk::Bool32 conservativeRasterizationPostDepthCoverage_ = 0 )
+        : primitiveOverestimationSize( primitiveOverestimationSize_ )
+        , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ )
+        , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ )
+        , primitiveUnderestimation( primitiveUnderestimation_ )
+        , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ )
+        , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ )
+        , degenerateLinesRasterized( degenerateLinesRasterized_ )
+        , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ )
+        , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ )
+      {}
+
+      PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT;
+      void* pNext = nullptr;
+      float primitiveOverestimationSize;
+      float maxExtraPrimitiveOverestimationSize;
+      float extraPrimitiveOverestimationSizeGranularity;
+      vk::Bool32 primitiveUnderestimation;
+      vk::Bool32 conservativePointAndLineRasterization;
+      vk::Bool32 degenerateTrianglesRasterized;
+      vk::Bool32 degenerateLinesRasterized;
+      vk::Bool32 fullyCoveredFragmentShaderInputVariable;
+      vk::Bool32 conservativeRasterizationPostDepthCoverage;
+    };
+    static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceConservativeRasterizationPropertiesEXT : public layout::PhysicalDeviceConservativeRasterizationPropertiesEXT
   {
     operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const&() const
     {
@@ -37553,34 +43562,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    float primitiveOverestimationSize;
-    float maxExtraPrimitiveOverestimationSize;
-    float extraPrimitiveOverestimationSizeGranularity;
-    Bool32 primitiveUnderestimation;
-    Bool32 conservativePointAndLineRasterization;
-    Bool32 degenerateTrianglesRasterized;
-    Bool32 degenerateLinesRasterized;
-    Bool32 fullyCoveredFragmentShaderInputVariable;
-    Bool32 conservativeRasterizationPostDepthCoverage;
+    using layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::sType;
   };
   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!" );
 
-  struct PhysicalDeviceCooperativeMatrixFeaturesNV
+  namespace layout
   {
-    PhysicalDeviceCooperativeMatrixFeaturesNV( Bool32 cooperativeMatrix_ = 0,
-                                               Bool32 cooperativeMatrixRobustBufferAccess_ = 0 )
-      : cooperativeMatrix( cooperativeMatrix_ )
-      , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ )
+    struct PhysicalDeviceCooperativeMatrixFeaturesNV
+    {
+    protected:
+      PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0,
+                                                 vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 )
+        : cooperativeMatrix( cooperativeMatrix_ )
+        , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ )
+      {}
+
+      PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 cooperativeMatrix;
+      vk::Bool32 cooperativeMatrixRobustBufferAccess;
+    };
+    static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceCooperativeMatrixFeaturesNV : public layout::PhysicalDeviceCooperativeMatrixFeaturesNV
+  {
+    PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0,
+                                               vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 )
+      : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( cooperativeMatrix_, cooperativeMatrixRobustBufferAccess_ )
     {}
 
     PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs )
     {
@@ -37594,13 +43621,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrix( Bool32 cooperativeMatrix_ )
+    PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrix( vk::Bool32 cooperativeMatrix_ )
     {
       cooperativeMatrix = cooperativeMatrix_;
       return *this;
     }
 
-    PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ )
+    PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrixRobustBufferAccess( vk::Bool32 cooperativeMatrixRobustBufferAccess_ )
     {
       cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_;
       return *this;
@@ -37630,16 +43657,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 cooperativeMatrix;
-    Bool32 cooperativeMatrixRobustBufferAccess;
+    using layout::PhysicalDeviceCooperativeMatrixFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceCooperativeMatrixPropertiesNV
+    {
+    protected:
+      PhysicalDeviceCooperativeMatrixPropertiesNV( vk::ShaderStageFlags cooperativeMatrixSupportedStages_ = vk::ShaderStageFlags() )
+        : cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ )
+      {}
+
+      PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV;
+      void* pNext = nullptr;
+      vk::ShaderStageFlags cooperativeMatrixSupportedStages;
+    };
+    static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceCooperativeMatrixPropertiesNV
+  struct PhysicalDeviceCooperativeMatrixPropertiesNV : public layout::PhysicalDeviceCooperativeMatrixPropertiesNV
   {
     operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const&() const
     {
@@ -37664,24 +43715,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    ShaderStageFlags cooperativeMatrixSupportedStages;
+    using layout::PhysicalDeviceCooperativeMatrixPropertiesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceCornerSampledImageFeaturesNV
+    {
+    protected:
+      PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 )
+        : cornerSampledImage( cornerSampledImage_ )
+      {}
+
+      PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 cornerSampledImage;
+    };
+    static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceCornerSampledImageFeaturesNV
+  struct PhysicalDeviceCornerSampledImageFeaturesNV : public layout::PhysicalDeviceCornerSampledImageFeaturesNV
   {
-    PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = 0 )
-      : cornerSampledImage( cornerSampledImage_ )
+    PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 )
+      : layout::PhysicalDeviceCornerSampledImageFeaturesNV( cornerSampledImage_ )
     {}
 
     PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceCornerSampledImageFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
     {
@@ -37695,7 +43770,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage( Bool32 cornerSampledImage_ )
+    PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage( vk::Bool32 cornerSampledImage_ )
     {
       cornerSampledImage = cornerSampledImage_;
       return *this;
@@ -37724,24 +43799,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 cornerSampledImage;
+    using layout::PhysicalDeviceCornerSampledImageFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceCoverageReductionModeFeaturesNV
+    {
+    protected:
+      PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 )
+        : coverageReductionMode( coverageReductionMode_ )
+      {}
+
+      PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceCoverageReductionModeFeaturesNV
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 coverageReductionMode;
+    };
+    static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceCoverageReductionModeFeaturesNV : public layout::PhysicalDeviceCoverageReductionModeFeaturesNV
   {
-    PhysicalDeviceCoverageReductionModeFeaturesNV( Bool32 coverageReductionMode_ = 0 )
-      : coverageReductionMode( coverageReductionMode_ )
+    PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 )
+      : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( coverageReductionMode_ )
     {}
 
     PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs )
     {
@@ -37755,7 +43854,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceCoverageReductionModeFeaturesNV & setCoverageReductionMode( Bool32 coverageReductionMode_ )
+    PhysicalDeviceCoverageReductionModeFeaturesNV & setCoverageReductionMode( vk::Bool32 coverageReductionMode_ )
     {
       coverageReductionMode = coverageReductionMode_;
       return *this;
@@ -37784,24 +43883,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 coverageReductionMode;
+    using layout::PhysicalDeviceCoverageReductionModeFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
+    {
+    protected:
+      PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 )
+        : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
+      {}
 
-  struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
+      PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 dedicatedAllocationImageAliasing;
+    };
+    static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : public layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
   {
-    PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( Bool32 dedicatedAllocationImageAliasing_ = 0 )
-      : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
+    PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 )
+      : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( dedicatedAllocationImageAliasing_ )
     {}
 
     PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs )
     {
@@ -37815,7 +43938,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setDedicatedAllocationImageAliasing( Bool32 dedicatedAllocationImageAliasing_ )
+    PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setDedicatedAllocationImageAliasing( vk::Bool32 dedicatedAllocationImageAliasing_ )
     {
       dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing_;
       return *this;
@@ -37844,24 +43967,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 dedicatedAllocationImageAliasing;
+    using layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceDepthClipEnableFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 )
+        : depthClipEnable( depthClipEnable_ )
+      {}
 
-  struct PhysicalDeviceDepthClipEnableFeaturesEXT
+      PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 depthClipEnable;
+    };
+    static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceDepthClipEnableFeaturesEXT : public layout::PhysicalDeviceDepthClipEnableFeaturesEXT
   {
-    PhysicalDeviceDepthClipEnableFeaturesEXT( Bool32 depthClipEnable_ = 0 )
-      : depthClipEnable( depthClipEnable_ )
+    PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 )
+      : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( depthClipEnable_ )
     {}
 
     PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs )
     {
@@ -37875,7 +44022,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceDepthClipEnableFeaturesEXT & setDepthClipEnable( Bool32 depthClipEnable_ )
+    PhysicalDeviceDepthClipEnableFeaturesEXT & setDepthClipEnable( vk::Bool32 depthClipEnable_ )
     {
       depthClipEnable = depthClipEnable_;
       return *this;
@@ -37904,15 +44051,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 depthClipEnable;
+    using layout::PhysicalDeviceDepthClipEnableFeaturesEXT::sType;
   };
   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!" );
 
-  struct PhysicalDeviceDepthStencilResolvePropertiesKHR
+  namespace layout
+  {
+    struct PhysicalDeviceDepthStencilResolvePropertiesKHR
+    {
+    protected:
+      PhysicalDeviceDepthStencilResolvePropertiesKHR( vk::ResolveModeFlagsKHR supportedDepthResolveModes_ = vk::ResolveModeFlagsKHR(),
+                                                      vk::ResolveModeFlagsKHR supportedStencilResolveModes_ = vk::ResolveModeFlagsKHR(),
+                                                      vk::Bool32 independentResolveNone_ = 0,
+                                                      vk::Bool32 independentResolve_ = 0 )
+        : supportedDepthResolveModes( supportedDepthResolveModes_ )
+        , supportedStencilResolveModes( supportedStencilResolveModes_ )
+        , independentResolveNone( independentResolveNone_ )
+        , independentResolve( independentResolve_ )
+      {}
+
+      PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(this) = rhs;
+      }
+
+      PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR;
+      void* pNext = nullptr;
+      vk::ResolveModeFlagsKHR supportedDepthResolveModes;
+      vk::ResolveModeFlagsKHR supportedStencilResolveModes;
+      vk::Bool32 independentResolveNone;
+      vk::Bool32 independentResolve;
+    };
+    static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceDepthStencilResolvePropertiesKHR : public layout::PhysicalDeviceDepthStencilResolvePropertiesKHR
   {
     operator VkPhysicalDeviceDepthStencilResolvePropertiesKHR const&() const
     {
@@ -37940,65 +44121,124 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    ResolveModeFlagsKHR supportedDepthResolveModes;
-    ResolveModeFlagsKHR supportedStencilResolveModes;
-    Bool32 independentResolveNone;
-    Bool32 independentResolve;
+    using layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::sType;
   };
   static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceDepthStencilResolvePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  struct PhysicalDeviceDescriptorIndexingFeaturesEXT
-  {
-    PhysicalDeviceDescriptorIndexingFeaturesEXT( Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0,
-                                                 Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0,
-                                                 Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0,
-                                                 Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0,
-                                                 Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0,
-                                                 Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0,
-                                                 Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0,
-                                                 Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0,
-                                                 Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0,
-                                                 Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0,
-                                                 Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0,
-                                                 Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0,
-                                                 Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0,
-                                                 Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0,
-                                                 Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0,
-                                                 Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0,
-                                                 Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0,
-                                                 Bool32 descriptorBindingPartiallyBound_ = 0,
-                                                 Bool32 descriptorBindingVariableDescriptorCount_ = 0,
-                                                 Bool32 runtimeDescriptorArray_ = 0 )
-      : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ )
-      , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ )
-      , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ )
-      , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ )
-      , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ )
-      , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ )
-      , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ )
-      , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ )
-      , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ )
-      , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ )
-      , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ )
-      , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ )
-      , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ )
-      , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ )
-      , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ )
-      , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ )
-      , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ )
-      , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ )
-      , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ )
-      , runtimeDescriptorArray( runtimeDescriptorArray_ )
+  namespace layout
+  {
+    struct PhysicalDeviceDescriptorIndexingFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0,
+                                                   vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0,
+                                                   vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0,
+                                                   vk::Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0,
+                                                   vk::Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0,
+                                                   vk::Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0,
+                                                   vk::Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0,
+                                                   vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0,
+                                                   vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0,
+                                                   vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0,
+                                                   vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0,
+                                                   vk::Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0,
+                                                   vk::Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0,
+                                                   vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0,
+                                                   vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0,
+                                                   vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0,
+                                                   vk::Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0,
+                                                   vk::Bool32 descriptorBindingPartiallyBound_ = 0,
+                                                   vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0,
+                                                   vk::Bool32 runtimeDescriptorArray_ = 0 )
+        : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ )
+        , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ )
+        , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ )
+        , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ )
+        , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ )
+        , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ )
+        , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ )
+        , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ )
+        , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ )
+        , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ )
+        , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ )
+        , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ )
+        , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ )
+        , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ )
+        , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ )
+        , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ )
+        , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ )
+        , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ )
+        , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ )
+        , runtimeDescriptorArray( runtimeDescriptorArray_ )
+      {}
+
+      PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 shaderInputAttachmentArrayDynamicIndexing;
+      vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing;
+      vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing;
+      vk::Bool32 shaderUniformBufferArrayNonUniformIndexing;
+      vk::Bool32 shaderSampledImageArrayNonUniformIndexing;
+      vk::Bool32 shaderStorageBufferArrayNonUniformIndexing;
+      vk::Bool32 shaderStorageImageArrayNonUniformIndexing;
+      vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing;
+      vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing;
+      vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing;
+      vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind;
+      vk::Bool32 descriptorBindingSampledImageUpdateAfterBind;
+      vk::Bool32 descriptorBindingStorageImageUpdateAfterBind;
+      vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind;
+      vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
+      vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
+      vk::Bool32 descriptorBindingUpdateUnusedWhilePending;
+      vk::Bool32 descriptorBindingPartiallyBound;
+      vk::Bool32 descriptorBindingVariableDescriptorCount;
+      vk::Bool32 runtimeDescriptorArray;
+    };
+    static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceDescriptorIndexingFeaturesEXT : public layout::PhysicalDeviceDescriptorIndexingFeaturesEXT
+  {
+    PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0,
+                                                 vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0,
+                                                 vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0,
+                                                 vk::Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0,
+                                                 vk::Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0,
+                                                 vk::Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0,
+                                                 vk::Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0,
+                                                 vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0,
+                                                 vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0,
+                                                 vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0,
+                                                 vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0,
+                                                 vk::Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0,
+                                                 vk::Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0,
+                                                 vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0,
+                                                 vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0,
+                                                 vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0,
+                                                 vk::Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0,
+                                                 vk::Bool32 descriptorBindingPartiallyBound_ = 0,
+                                                 vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0,
+                                                 vk::Bool32 runtimeDescriptorArray_ = 0 )
+      : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( shaderInputAttachmentArrayDynamicIndexing_, shaderUniformTexelBufferArrayDynamicIndexing_, shaderStorageTexelBufferArrayDynamicIndexing_, shaderUniformBufferArrayNonUniformIndexing_, shaderSampledImageArrayNonUniformIndexing_, shaderStorageBufferArrayNonUniformIndexing_, shaderStorageImageArrayNonUniformIndexing_, shaderInputAttachmentArrayNonUniformIndexing_, shaderUniformTexelBufferArrayNonUniformIndexing_, shaderStorageTexelBufferArrayNonUniformIndexing_, descriptorBindingUniformBufferUpdateAfterBind_, descriptorBindingSampledImageUpdateAfterBind_, descriptorBindingStorageImageUpdateAfterBind_, descriptorBindingStorageBufferUpdateAfterBind_, descriptorBindingUniformTexelBufferUpdateAfterBind_, descriptorBindingStorageTexelBufferUpdateAfterBind_, descriptorBindingUpdateUnusedWhilePending_, descriptorBindingPartiallyBound_, descriptorBindingVariableDescriptorCount_, runtimeDescriptorArray_ )
     {}
 
     PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
     {
@@ -38012,121 +44252,121 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayDynamicIndexing( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ )
     {
       shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayDynamicIndexing( vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ )
     {
       shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayDynamicIndexing( vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ )
     {
       shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformBufferArrayNonUniformIndexing( vk::Bool32 shaderUniformBufferArrayNonUniformIndexing_ )
     {
       shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderSampledImageArrayNonUniformIndexing( vk::Bool32 shaderSampledImageArrayNonUniformIndexing_ )
     {
       shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageBufferArrayNonUniformIndexing( vk::Bool32 shaderStorageBufferArrayNonUniformIndexing_ )
     {
       shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageImageArrayNonUniformIndexing( vk::Bool32 shaderStorageImageArrayNonUniformIndexing_ )
     {
       shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayNonUniformIndexing( vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing_ )
     {
       shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayNonUniformIndexing( vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ )
     {
       shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayNonUniformIndexing( vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ )
     {
       shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformBufferUpdateAfterBind( vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind_ )
     {
       descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingSampledImageUpdateAfterBind( vk::Bool32 descriptorBindingSampledImageUpdateAfterBind_ )
     {
       descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageImageUpdateAfterBind( vk::Bool32 descriptorBindingStorageImageUpdateAfterBind_ )
     {
       descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageBufferUpdateAfterBind( vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind_ )
     {
       descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformTexelBufferUpdateAfterBind( vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ )
     {
       descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageTexelBufferUpdateAfterBind( vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ )
     {
       descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUpdateUnusedWhilePending( vk::Bool32 descriptorBindingUpdateUnusedWhilePending_ )
     {
       descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingPartiallyBound( vk::Bool32 descriptorBindingPartiallyBound_ )
     {
       descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingVariableDescriptorCount( vk::Bool32 descriptorBindingVariableDescriptorCount_ )
     {
       descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT & setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setRuntimeDescriptorArray( vk::Bool32 runtimeDescriptorArray_ )
     {
       runtimeDescriptorArray = runtimeDescriptorArray_;
       return *this;
@@ -38174,34 +44414,106 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderInputAttachmentArrayDynamicIndexing;
-    Bool32 shaderUniformTexelBufferArrayDynamicIndexing;
-    Bool32 shaderStorageTexelBufferArrayDynamicIndexing;
-    Bool32 shaderUniformBufferArrayNonUniformIndexing;
-    Bool32 shaderSampledImageArrayNonUniformIndexing;
-    Bool32 shaderStorageBufferArrayNonUniformIndexing;
-    Bool32 shaderStorageImageArrayNonUniformIndexing;
-    Bool32 shaderInputAttachmentArrayNonUniformIndexing;
-    Bool32 shaderUniformTexelBufferArrayNonUniformIndexing;
-    Bool32 shaderStorageTexelBufferArrayNonUniformIndexing;
-    Bool32 descriptorBindingUniformBufferUpdateAfterBind;
-    Bool32 descriptorBindingSampledImageUpdateAfterBind;
-    Bool32 descriptorBindingStorageImageUpdateAfterBind;
-    Bool32 descriptorBindingStorageBufferUpdateAfterBind;
-    Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
-    Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
-    Bool32 descriptorBindingUpdateUnusedWhilePending;
-    Bool32 descriptorBindingPartiallyBound;
-    Bool32 descriptorBindingVariableDescriptorCount;
-    Bool32 runtimeDescriptorArray;
+    using layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::sType;
   };
   static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceDescriptorIndexingFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceDescriptorIndexingPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceDescriptorIndexingPropertiesEXT( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = 0,
+                                                     vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = 0,
+                                                     vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = 0,
+                                                     vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ = 0,
+                                                     vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative_ = 0,
+                                                     vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ = 0,
+                                                     vk::Bool32 robustBufferAccessUpdateAfterBind_ = 0,
+                                                     vk::Bool32 quadDivergentImplicitLod_ = 0,
+                                                     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ = 0,
+                                                     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ = 0,
+                                                     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ = 0,
+                                                     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ = 0,
+                                                     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ = 0,
+                                                     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ = 0,
+                                                     uint32_t maxPerStageUpdateAfterBindResources_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindSamplers_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ = 0 )
+        : maxUpdateAfterBindDescriptorsInAllPools( maxUpdateAfterBindDescriptorsInAllPools_ )
+        , shaderUniformBufferArrayNonUniformIndexingNative( shaderUniformBufferArrayNonUniformIndexingNative_ )
+        , shaderSampledImageArrayNonUniformIndexingNative( shaderSampledImageArrayNonUniformIndexingNative_ )
+        , shaderStorageBufferArrayNonUniformIndexingNative( shaderStorageBufferArrayNonUniformIndexingNative_ )
+        , shaderStorageImageArrayNonUniformIndexingNative( shaderStorageImageArrayNonUniformIndexingNative_ )
+        , shaderInputAttachmentArrayNonUniformIndexingNative( shaderInputAttachmentArrayNonUniformIndexingNative_ )
+        , robustBufferAccessUpdateAfterBind( robustBufferAccessUpdateAfterBind_ )
+        , quadDivergentImplicitLod( quadDivergentImplicitLod_ )
+        , maxPerStageDescriptorUpdateAfterBindSamplers( maxPerStageDescriptorUpdateAfterBindSamplers_ )
+        , maxPerStageDescriptorUpdateAfterBindUniformBuffers( maxPerStageDescriptorUpdateAfterBindUniformBuffers_ )
+        , maxPerStageDescriptorUpdateAfterBindStorageBuffers( maxPerStageDescriptorUpdateAfterBindStorageBuffers_ )
+        , maxPerStageDescriptorUpdateAfterBindSampledImages( maxPerStageDescriptorUpdateAfterBindSampledImages_ )
+        , maxPerStageDescriptorUpdateAfterBindStorageImages( maxPerStageDescriptorUpdateAfterBindStorageImages_ )
+        , maxPerStageDescriptorUpdateAfterBindInputAttachments( maxPerStageDescriptorUpdateAfterBindInputAttachments_ )
+        , maxPerStageUpdateAfterBindResources( maxPerStageUpdateAfterBindResources_ )
+        , maxDescriptorSetUpdateAfterBindSamplers( maxDescriptorSetUpdateAfterBindSamplers_ )
+        , maxDescriptorSetUpdateAfterBindUniformBuffers( maxDescriptorSetUpdateAfterBindUniformBuffers_ )
+        , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ )
+        , maxDescriptorSetUpdateAfterBindStorageBuffers( maxDescriptorSetUpdateAfterBindStorageBuffers_ )
+        , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ )
+        , maxDescriptorSetUpdateAfterBindSampledImages( maxDescriptorSetUpdateAfterBindSampledImages_ )
+        , maxDescriptorSetUpdateAfterBindStorageImages( maxDescriptorSetUpdateAfterBindStorageImages_ )
+        , maxDescriptorSetUpdateAfterBindInputAttachments( maxDescriptorSetUpdateAfterBindInputAttachments_ )
+      {}
+
+      PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t maxUpdateAfterBindDescriptorsInAllPools;
+      vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative;
+      vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative;
+      vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative;
+      vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative;
+      vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative;
+      vk::Bool32 robustBufferAccessUpdateAfterBind;
+      vk::Bool32 quadDivergentImplicitLod;
+      uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
+      uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+      uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+      uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
+      uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
+      uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
+      uint32_t maxPerStageUpdateAfterBindResources;
+      uint32_t maxDescriptorSetUpdateAfterBindSamplers;
+      uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
+      uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+      uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
+      uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+      uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
+      uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
+      uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+    };
+    static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceDescriptorIndexingPropertiesEXT
+  struct PhysicalDeviceDescriptorIndexingPropertiesEXT : public layout::PhysicalDeviceDescriptorIndexingPropertiesEXT
   {
     operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT const&() const
     {
@@ -38248,37 +44560,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxUpdateAfterBindDescriptorsInAllPools;
-    Bool32 shaderUniformBufferArrayNonUniformIndexingNative;
-    Bool32 shaderSampledImageArrayNonUniformIndexingNative;
-    Bool32 shaderStorageBufferArrayNonUniformIndexingNative;
-    Bool32 shaderStorageImageArrayNonUniformIndexingNative;
-    Bool32 shaderInputAttachmentArrayNonUniformIndexingNative;
-    Bool32 robustBufferAccessUpdateAfterBind;
-    Bool32 quadDivergentImplicitLod;
-    uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
-    uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
-    uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
-    uint32_t maxPerStageUpdateAfterBindResources;
-    uint32_t maxDescriptorSetUpdateAfterBindSamplers;
-    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
-    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
-    uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
-    uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+    using layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::sType;
   };
   static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceDescriptorIndexingPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceDiscardRectanglePropertiesEXT
+    {
+    protected:
+      PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 )
+        : maxDiscardRectangles( maxDiscardRectangles_ )
+      {}
+
+      PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t maxDiscardRectangles;
+    };
+    static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceDiscardRectanglePropertiesEXT
+  struct PhysicalDeviceDiscardRectanglePropertiesEXT : public layout::PhysicalDeviceDiscardRectanglePropertiesEXT
   {
     operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const
     {
@@ -38303,15 +44618,51 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxDiscardRectangles;
+    using layout::PhysicalDeviceDiscardRectanglePropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceDriverPropertiesKHR
+    {
+    protected:
+      PhysicalDeviceDriverPropertiesKHR( vk::DriverIdKHR driverID_ = vk::DriverIdKHR::eAmdProprietary,
+                                         std::array<char,VK_MAX_DRIVER_NAME_SIZE_KHR> const& driverName_ = { { 0 } },
+                                         std::array<char,VK_MAX_DRIVER_INFO_SIZE_KHR> const& driverInfo_ = { { 0 } },
+                                         vk::ConformanceVersionKHR conformanceVersion_ = vk::ConformanceVersionKHR() )
+        : driverID( driverID_ )
+        , conformanceVersion( conformanceVersion_ )
+      {
+        memcpy( &driverName, driverName_.data(), VK_MAX_DRIVER_NAME_SIZE_KHR * sizeof( char ) );
+        memcpy( &driverInfo, driverInfo_.data(), VK_MAX_DRIVER_INFO_SIZE_KHR * sizeof( char ) );
+      
+      }
+
+      PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this) = rhs;
+      }
+
+      PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceDriverPropertiesKHR
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR;
+      void* pNext = nullptr;
+      vk::DriverIdKHR driverID;
+      char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
+      char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
+      vk::ConformanceVersionKHR conformanceVersion;
+    };
+    static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceDriverPropertiesKHR : public layout::PhysicalDeviceDriverPropertiesKHR
   {
     operator VkPhysicalDeviceDriverPropertiesKHR const&() const
     {
@@ -38339,27 +44690,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    DriverIdKHR driverID;
-    char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
-    char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
-    ConformanceVersionKHR conformanceVersion;
+    using layout::PhysicalDeviceDriverPropertiesKHR::sType;
   };
   static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceDriverPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceExclusiveScissorFeaturesNV
+    {
+    protected:
+      PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 )
+        : exclusiveScissor( exclusiveScissor_ )
+      {}
+
+      PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceExclusiveScissorFeaturesNV
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 exclusiveScissor;
+    };
+    static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceExclusiveScissorFeaturesNV : public layout::PhysicalDeviceExclusiveScissorFeaturesNV
   {
-    PhysicalDeviceExclusiveScissorFeaturesNV( Bool32 exclusiveScissor_ = 0 )
-      : exclusiveScissor( exclusiveScissor_ )
+    PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 )
+      : layout::PhysicalDeviceExclusiveScissorFeaturesNV( exclusiveScissor_ )
     {}
 
     PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceExclusiveScissorFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
     {
@@ -38373,7 +44745,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor( Bool32 exclusiveScissor_ )
+    PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor( vk::Bool32 exclusiveScissor_ )
     {
       exclusiveScissor = exclusiveScissor_;
       return *this;
@@ -38402,28 +44774,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 exclusiveScissor;
+    using layout::PhysicalDeviceExclusiveScissorFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceExternalBufferInfo
+    {
+    protected:
+      PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
+                                        vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
+                                        vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+        : flags( flags_ )
+        , usage( usage_ )
+        , handleType( handleType_ )
+      {}
+
+      PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceExternalBufferInfo
+      PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
+      const void* pNext = nullptr;
+      vk::BufferCreateFlags flags;
+      vk::BufferUsageFlags usage;
+      vk::ExternalMemoryHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceExternalBufferInfo : public layout::PhysicalDeviceExternalBufferInfo
   {
-    PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
-                                      BufferUsageFlags usage_ = BufferUsageFlags(),
-                                      ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
-      : flags( flags_ )
-      , usage( usage_ )
-      , handleType( handleType_ )
+    PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
+                                      vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
+                                      vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+      : layout::PhysicalDeviceExternalBufferInfo( flags_, usage_, handleType_ )
     {}
 
     PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceExternalBufferInfo( rhs )
+    {}
 
     PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs )
     {
@@ -38437,19 +44837,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceExternalBufferInfo & setFlags( BufferCreateFlags flags_ )
+    PhysicalDeviceExternalBufferInfo & setFlags( vk::BufferCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PhysicalDeviceExternalBufferInfo & setUsage( BufferUsageFlags usage_ )
+    PhysicalDeviceExternalBufferInfo & setUsage( vk::BufferUsageFlags usage_ )
     {
       usage = usage_;
       return *this;
     }
 
-    PhysicalDeviceExternalBufferInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    PhysicalDeviceExternalBufferInfo & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -38480,26 +44880,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
-
-  public:
-    const void* pNext = nullptr;
-    BufferCreateFlags flags;
-    BufferUsageFlags usage;
-    ExternalMemoryHandleTypeFlagBits handleType;
+    using layout::PhysicalDeviceExternalBufferInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceExternalFenceInfo
+    {
+    protected:
+      PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+        : handleType( handleType_ )
+      {}
+
+      PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceExternalFenceInfo
+      PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
+      const void* pNext = nullptr;
+      vk::ExternalFenceHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceExternalFenceInfo : public layout::PhysicalDeviceExternalFenceInfo
   {
-    PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
-      : handleType( handleType_ )
+    PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+      : layout::PhysicalDeviceExternalFenceInfo( handleType_ )
     {}
 
     PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceExternalFenceInfo( rhs )
+    {}
 
     PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs )
     {
@@ -38513,7 +44935,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceExternalFenceInfo & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    PhysicalDeviceExternalFenceInfo & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -38542,24 +44964,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalFenceHandleTypeFlagBits handleType;
+    using layout::PhysicalDeviceExternalFenceInfo::sType;
   };
   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!" );
 
-  struct PhysicalDeviceExternalImageFormatInfo
+  namespace layout
   {
-    PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
-      : handleType( handleType_ )
+    struct PhysicalDeviceExternalImageFormatInfo
+    {
+    protected:
+      PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+        : handleType( handleType_ )
+      {}
+
+      PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this) = rhs;
+      }
+
+      PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
+      const void* pNext = nullptr;
+      vk::ExternalMemoryHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceExternalImageFormatInfo : public layout::PhysicalDeviceExternalImageFormatInfo
+  {
+    PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+      : layout::PhysicalDeviceExternalImageFormatInfo( handleType_ )
     {}
 
     PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceExternalImageFormatInfo( rhs )
+    {}
 
     PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
     {
@@ -38573,7 +45019,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceExternalImageFormatInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    PhysicalDeviceExternalImageFormatInfo & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -38602,15 +45048,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBits handleType;
+    using layout::PhysicalDeviceExternalImageFormatInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceExternalMemoryHostPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceExternalMemoryHostPropertiesEXT( vk::DeviceSize minImportedHostPointerAlignment_ = 0 )
+        : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
+      {}
+
+      PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
+      void* pNext = nullptr;
+      vk::DeviceSize minImportedHostPointerAlignment;
+    };
+    static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceExternalMemoryHostPropertiesEXT
+  struct PhysicalDeviceExternalMemoryHostPropertiesEXT : public layout::PhysicalDeviceExternalMemoryHostPropertiesEXT
   {
     operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const
     {
@@ -38635,24 +45106,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    DeviceSize minImportedHostPointerAlignment;
+    using layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceExternalSemaphoreInfo
+    {
+    protected:
+      PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+        : handleType( handleType_ )
+      {}
+
+      PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this) = rhs;
+      }
+
+      PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
+      const void* pNext = nullptr;
+      vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceExternalSemaphoreInfo
+  struct PhysicalDeviceExternalSemaphoreInfo : public layout::PhysicalDeviceExternalSemaphoreInfo
   {
-    PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
-      : handleType( handleType_ )
+    PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+      : layout::PhysicalDeviceExternalSemaphoreInfo( handleType_ )
     {}
 
     PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceExternalSemaphoreInfo( rhs )
+    {}
 
     PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
     {
@@ -38666,7 +45161,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceExternalSemaphoreInfo & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    PhysicalDeviceExternalSemaphoreInfo & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -38695,24 +45190,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
+    using layout::PhysicalDeviceExternalSemaphoreInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceFeatures2
+    {
+    protected:
+      PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() )
+        : features( features_ )
+      {}
+
+      PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceFeatures2
+      PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceFeatures2;
+      void* pNext = nullptr;
+      vk::PhysicalDeviceFeatures features;
+    };
+    static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceFeatures2 : public layout::PhysicalDeviceFeatures2
   {
-    PhysicalDeviceFeatures2( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() )
-      : features( features_ )
+    PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() )
+      : layout::PhysicalDeviceFeatures2( features_ )
     {}
 
     PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceFeatures2( rhs )
+    {}
 
     PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs )
     {
@@ -38726,7 +45245,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceFeatures2 & setFeatures( PhysicalDeviceFeatures features_ )
+    PhysicalDeviceFeatures2 & setFeatures( vk::PhysicalDeviceFeatures features_ )
     {
       features = features_;
       return *this;
@@ -38755,85 +45274,88 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceFeatures2;
-
-  public:
-    void* pNext = nullptr;
-    PhysicalDeviceFeatures features;
+    using layout::PhysicalDeviceFeatures2::sType;
   };
   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!" );
 
-  struct PhysicalDeviceFloat16Int8FeaturesKHR
+  namespace layout
   {
-    PhysicalDeviceFloat16Int8FeaturesKHR( Bool32 shaderFloat16_ = 0,
-                                          Bool32 shaderInt8_ = 0 )
-      : shaderFloat16( shaderFloat16_ )
-      , shaderInt8( shaderInt8_ )
-    {}
-
-    PhysicalDeviceFloat16Int8FeaturesKHR( VkPhysicalDeviceFloat16Int8FeaturesKHR const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceFloat16Int8FeaturesKHR*>(this) = rhs;
-    }
-
-    PhysicalDeviceFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceFloat16Int8FeaturesKHR const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceFloat16Int8FeaturesKHR*>(this) = rhs;
-      return *this;
-    }
-
-    PhysicalDeviceFloat16Int8FeaturesKHR & setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceFloat16Int8FeaturesKHR & setShaderFloat16( Bool32 shaderFloat16_ )
-    {
-      shaderFloat16 = shaderFloat16_;
-      return *this;
-    }
-
-    PhysicalDeviceFloat16Int8FeaturesKHR & setShaderInt8( Bool32 shaderInt8_ )
-    {
-      shaderInt8 = shaderInt8_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceFloat16Int8FeaturesKHR const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceFloat16Int8FeaturesKHR*>( this );
-    }
-
-    operator VkPhysicalDeviceFloat16Int8FeaturesKHR &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceFloat16Int8FeaturesKHR*>( this );
-    }
-
-    bool operator==( PhysicalDeviceFloat16Int8FeaturesKHR const& rhs ) const
+    struct PhysicalDeviceFloatControlsPropertiesKHR
     {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( shaderFloat16 == rhs.shaderFloat16 )
-          && ( shaderInt8 == rhs.shaderInt8 );
-    }
+    protected:
+      PhysicalDeviceFloatControlsPropertiesKHR( vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence_ = vk::ShaderFloatControlsIndependenceKHR::e32BitOnly,
+                                                vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence_ = vk::ShaderFloatControlsIndependenceKHR::e32BitOnly,
+                                                vk::Bool32 shaderSignedZeroInfNanPreserveFloat16_ = 0,
+                                                vk::Bool32 shaderSignedZeroInfNanPreserveFloat32_ = 0,
+                                                vk::Bool32 shaderSignedZeroInfNanPreserveFloat64_ = 0,
+                                                vk::Bool32 shaderDenormPreserveFloat16_ = 0,
+                                                vk::Bool32 shaderDenormPreserveFloat32_ = 0,
+                                                vk::Bool32 shaderDenormPreserveFloat64_ = 0,
+                                                vk::Bool32 shaderDenormFlushToZeroFloat16_ = 0,
+                                                vk::Bool32 shaderDenormFlushToZeroFloat32_ = 0,
+                                                vk::Bool32 shaderDenormFlushToZeroFloat64_ = 0,
+                                                vk::Bool32 shaderRoundingModeRTEFloat16_ = 0,
+                                                vk::Bool32 shaderRoundingModeRTEFloat32_ = 0,
+                                                vk::Bool32 shaderRoundingModeRTEFloat64_ = 0,
+                                                vk::Bool32 shaderRoundingModeRTZFloat16_ = 0,
+                                                vk::Bool32 shaderRoundingModeRTZFloat32_ = 0,
+                                                vk::Bool32 shaderRoundingModeRTZFloat64_ = 0 )
+        : denormBehaviorIndependence( denormBehaviorIndependence_ )
+        , roundingModeIndependence( roundingModeIndependence_ )
+        , shaderSignedZeroInfNanPreserveFloat16( shaderSignedZeroInfNanPreserveFloat16_ )
+        , shaderSignedZeroInfNanPreserveFloat32( shaderSignedZeroInfNanPreserveFloat32_ )
+        , shaderSignedZeroInfNanPreserveFloat64( shaderSignedZeroInfNanPreserveFloat64_ )
+        , shaderDenormPreserveFloat16( shaderDenormPreserveFloat16_ )
+        , shaderDenormPreserveFloat32( shaderDenormPreserveFloat32_ )
+        , shaderDenormPreserveFloat64( shaderDenormPreserveFloat64_ )
+        , shaderDenormFlushToZeroFloat16( shaderDenormFlushToZeroFloat16_ )
+        , shaderDenormFlushToZeroFloat32( shaderDenormFlushToZeroFloat32_ )
+        , shaderDenormFlushToZeroFloat64( shaderDenormFlushToZeroFloat64_ )
+        , shaderRoundingModeRTEFloat16( shaderRoundingModeRTEFloat16_ )
+        , shaderRoundingModeRTEFloat32( shaderRoundingModeRTEFloat32_ )
+        , shaderRoundingModeRTEFloat64( shaderRoundingModeRTEFloat64_ )
+        , shaderRoundingModeRTZFloat16( shaderRoundingModeRTZFloat16_ )
+        , shaderRoundingModeRTZFloat32( shaderRoundingModeRTZFloat32_ )
+        , shaderRoundingModeRTZFloat64( shaderRoundingModeRTZFloat64_ )
+      {}
 
-    bool operator!=( PhysicalDeviceFloat16Int8FeaturesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
+      PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR*>(this) = rhs;
+      }
 
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR;
+      PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR*>(this) = rhs;
+        return *this;
+      }
 
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderFloat16;
-    Bool32 shaderInt8;
-  };
-  static_assert( sizeof( PhysicalDeviceFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" );
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR;
+      void* pNext = nullptr;
+      vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence;
+      vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence;
+      vk::Bool32 shaderSignedZeroInfNanPreserveFloat16;
+      vk::Bool32 shaderSignedZeroInfNanPreserveFloat32;
+      vk::Bool32 shaderSignedZeroInfNanPreserveFloat64;
+      vk::Bool32 shaderDenormPreserveFloat16;
+      vk::Bool32 shaderDenormPreserveFloat32;
+      vk::Bool32 shaderDenormPreserveFloat64;
+      vk::Bool32 shaderDenormFlushToZeroFloat16;
+      vk::Bool32 shaderDenormFlushToZeroFloat32;
+      vk::Bool32 shaderDenormFlushToZeroFloat64;
+      vk::Bool32 shaderRoundingModeRTEFloat16;
+      vk::Bool32 shaderRoundingModeRTEFloat32;
+      vk::Bool32 shaderRoundingModeRTEFloat64;
+      vk::Bool32 shaderRoundingModeRTZFloat16;
+      vk::Bool32 shaderRoundingModeRTZFloat32;
+      vk::Bool32 shaderRoundingModeRTZFloat64;
+    };
+    static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceFloatControlsPropertiesKHR
+  struct PhysicalDeviceFloatControlsPropertiesKHR : public layout::PhysicalDeviceFloatControlsPropertiesKHR
   {
     operator VkPhysicalDeviceFloatControlsPropertiesKHR const&() const
     {
@@ -38849,8 +45371,8 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( separateDenormSettings == rhs.separateDenormSettings )
-          && ( separateRoundingModeSettings == rhs.separateRoundingModeSettings )
+          && ( denormBehaviorIndependence == rhs.denormBehaviorIndependence )
+          && ( roundingModeIndependence == rhs.roundingModeIndependence )
           && ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 )
           && ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 )
           && ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 )
@@ -38874,31 +45396,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 separateDenormSettings;
-    Bool32 separateRoundingModeSettings;
-    Bool32 shaderSignedZeroInfNanPreserveFloat16;
-    Bool32 shaderSignedZeroInfNanPreserveFloat32;
-    Bool32 shaderSignedZeroInfNanPreserveFloat64;
-    Bool32 shaderDenormPreserveFloat16;
-    Bool32 shaderDenormPreserveFloat32;
-    Bool32 shaderDenormPreserveFloat64;
-    Bool32 shaderDenormFlushToZeroFloat16;
-    Bool32 shaderDenormFlushToZeroFloat32;
-    Bool32 shaderDenormFlushToZeroFloat64;
-    Bool32 shaderRoundingModeRTEFloat16;
-    Bool32 shaderRoundingModeRTEFloat32;
-    Bool32 shaderRoundingModeRTEFloat64;
-    Bool32 shaderRoundingModeRTZFloat16;
-    Bool32 shaderRoundingModeRTZFloat32;
-    Bool32 shaderRoundingModeRTZFloat64;
+    using layout::PhysicalDeviceFloatControlsPropertiesKHR::sType;
   };
   static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceFloatControlsPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  struct PhysicalDeviceFragmentDensityMapFeaturesEXT
+  namespace layout
+  {
+    struct PhysicalDeviceFragmentDensityMapFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceFragmentDensityMapFeaturesEXT( vk::Bool32 fragmentDensityMap_ = 0,
+                                                   vk::Bool32 fragmentDensityMapDynamic_ = 0,
+                                                   vk::Bool32 fragmentDensityMapNonSubsampledImages_ = 0 )
+        : fragmentDensityMap( fragmentDensityMap_ )
+        , fragmentDensityMapDynamic( fragmentDensityMapDynamic_ )
+        , fragmentDensityMapNonSubsampledImages( fragmentDensityMapNonSubsampledImages_ )
+      {}
+
+      PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 fragmentDensityMap;
+      vk::Bool32 fragmentDensityMapDynamic;
+      vk::Bool32 fragmentDensityMapNonSubsampledImages;
+    };
+    static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceFragmentDensityMapFeaturesEXT : public layout::PhysicalDeviceFragmentDensityMapFeaturesEXT
   {
     operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const&() const
     {
@@ -38925,17 +45462,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 fragmentDensityMap;
-    Bool32 fragmentDensityMapDynamic;
-    Bool32 fragmentDensityMapNonSubsampledImages;
+    using layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceFragmentDensityMapPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceFragmentDensityMapPropertiesEXT( vk::Extent2D minFragmentDensityTexelSize_ = vk::Extent2D(),
+                                                     vk::Extent2D maxFragmentDensityTexelSize_ = vk::Extent2D(),
+                                                     vk::Bool32 fragmentDensityInvocations_ = 0 )
+        : minFragmentDensityTexelSize( minFragmentDensityTexelSize_ )
+        , maxFragmentDensityTexelSize( maxFragmentDensityTexelSize_ )
+        , fragmentDensityInvocations( fragmentDensityInvocations_ )
+      {}
+
+      PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceFragmentDensityMapPropertiesEXT
+      PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT;
+      void* pNext = nullptr;
+      vk::Extent2D minFragmentDensityTexelSize;
+      vk::Extent2D maxFragmentDensityTexelSize;
+      vk::Bool32 fragmentDensityInvocations;
+    };
+    static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceFragmentDensityMapPropertiesEXT : public layout::PhysicalDeviceFragmentDensityMapPropertiesEXT
   {
     operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const&() const
     {
@@ -38962,26 +45528,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Extent2D minFragmentDensityTexelSize;
-    Extent2D maxFragmentDensityTexelSize;
-    Bool32 fragmentDensityInvocations;
+    using layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
+    {
+    protected:
+      PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 )
+        : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
+      {}
+
+      PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
+      PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 fragmentShaderBarycentric;
+    };
+    static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV : public layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV
   {
-    PhysicalDeviceFragmentShaderBarycentricFeaturesNV( Bool32 fragmentShaderBarycentric_ = 0 )
-      : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 )
+      : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( fragmentShaderBarycentric_ )
     {}
 
     PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
     {
@@ -38995,7 +45583,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setFragmentShaderBarycentric( vk::Bool32 fragmentShaderBarycentric_ )
     {
       fragmentShaderBarycentric = fragmentShaderBarycentric_;
       return *this;
@@ -39024,28 +45612,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 fragmentShaderBarycentric;
+    using layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::sType;
   };
   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!" );
 
-  struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
+  namespace layout
   {
-    PhysicalDeviceFragmentShaderInterlockFeaturesEXT( Bool32 fragmentShaderSampleInterlock_ = 0,
-                                                      Bool32 fragmentShaderPixelInterlock_ = 0,
-                                                      Bool32 fragmentShaderShadingRateInterlock_ = 0 )
-      : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ )
-      , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ )
-      , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ )
+    struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0,
+                                                        vk::Bool32 fragmentShaderPixelInterlock_ = 0,
+                                                        vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 )
+        : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ )
+        , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ )
+        , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ )
+      {}
+
+      PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 fragmentShaderSampleInterlock;
+      vk::Bool32 fragmentShaderPixelInterlock;
+      vk::Bool32 fragmentShaderShadingRateInterlock;
+    };
+    static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT : public layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT
+  {
+    PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0,
+                                                      vk::Bool32 fragmentShaderPixelInterlock_ = 0,
+                                                      vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 )
+      : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( fragmentShaderSampleInterlock_, fragmentShaderPixelInterlock_, fragmentShaderShadingRateInterlock_ )
     {}
 
     PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs )
     {
@@ -39059,19 +45675,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderSampleInterlock( Bool32 fragmentShaderSampleInterlock_ )
+    PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderSampleInterlock( vk::Bool32 fragmentShaderSampleInterlock_ )
     {
       fragmentShaderSampleInterlock = fragmentShaderSampleInterlock_;
       return *this;
     }
 
-    PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderPixelInterlock( Bool32 fragmentShaderPixelInterlock_ )
+    PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderPixelInterlock( vk::Bool32 fragmentShaderPixelInterlock_ )
     {
       fragmentShaderPixelInterlock = fragmentShaderPixelInterlock_;
       return *this;
     }
 
-    PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderShadingRateInterlock( Bool32 fragmentShaderShadingRateInterlock_ )
+    PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderShadingRateInterlock( vk::Bool32 fragmentShaderShadingRateInterlock_ )
     {
       fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock_;
       return *this;
@@ -39102,17 +45718,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 fragmentShaderSampleInterlock;
-    Bool32 fragmentShaderPixelInterlock;
-    Bool32 fragmentShaderShadingRateInterlock;
+    using layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceGroupProperties
+    {
+    protected:
+      PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = 0,
+                                     std::array<vk::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE> const& physicalDevices_ = { { vk::PhysicalDevice() } },
+                                     vk::Bool32 subsetAllocation_ = 0 )
+        : physicalDeviceCount( physicalDeviceCount_ )
+        , subsetAllocation( subsetAllocation_ )
+      {
+        memcpy( &physicalDevices, physicalDevices_.data(), VK_MAX_DEVICE_GROUP_SIZE * sizeof( vk::PhysicalDevice ) );
+      
+      }
+
+      PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this) = rhs;
+      }
+
+      PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceGroupProperties
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceGroupProperties;
+      void* pNext = nullptr;
+      uint32_t physicalDeviceCount;
+      vk::PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+      vk::Bool32 subsetAllocation;
+    };
+    static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceGroupProperties : public layout::PhysicalDeviceGroupProperties
   {
     operator VkPhysicalDeviceGroupProperties const&() const
     {
@@ -39129,7 +45776,7 @@ namespace VULKAN_HPP_NAMESPACE
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
           && ( physicalDeviceCount == rhs.physicalDeviceCount )
-          && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( PhysicalDevice ) ) == 0 )
+          && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( vk::PhysicalDevice ) ) == 0 )
           && ( subsetAllocation == rhs.subsetAllocation );
     }
 
@@ -39139,26 +45786,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceGroupProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t physicalDeviceCount;
-    PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
-    Bool32 subsetAllocation;
+    using layout::PhysicalDeviceGroupProperties::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceHostQueryResetFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 )
+        : hostQueryReset( hostQueryReset_ )
+      {}
+
+      PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 hostQueryReset;
+    };
+    static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceHostQueryResetFeaturesEXT
+  struct PhysicalDeviceHostQueryResetFeaturesEXT : public layout::PhysicalDeviceHostQueryResetFeaturesEXT
   {
-    PhysicalDeviceHostQueryResetFeaturesEXT( Bool32 hostQueryReset_ = 0 )
-      : hostQueryReset( hostQueryReset_ )
+    PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 )
+      : layout::PhysicalDeviceHostQueryResetFeaturesEXT( hostQueryReset_ )
     {}
 
     PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceHostQueryResetFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs )
     {
@@ -39172,7 +45841,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceHostQueryResetFeaturesEXT & setHostQueryReset( Bool32 hostQueryReset_ )
+    PhysicalDeviceHostQueryResetFeaturesEXT & setHostQueryReset( vk::Bool32 hostQueryReset_ )
     {
       hostQueryReset = hostQueryReset_;
       return *this;
@@ -39201,15 +45870,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 hostQueryReset;
+    using layout::PhysicalDeviceHostQueryResetFeaturesEXT::sType;
   };
   static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceHostQueryResetFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceIDProperties
+    {
+    protected:
+      PhysicalDeviceIDProperties( std::array<uint8_t,VK_UUID_SIZE> const& deviceUUID_ = { { 0 } },
+                                  std::array<uint8_t,VK_UUID_SIZE> const& driverUUID_ = { { 0 } },
+                                  std::array<uint8_t,VK_LUID_SIZE> const& deviceLUID_ = { { 0 } },
+                                  uint32_t deviceNodeMask_ = 0,
+                                  vk::Bool32 deviceLUIDValid_ = 0 )
+        : deviceNodeMask( deviceNodeMask_ )
+        , deviceLUIDValid( deviceLUIDValid_ )
+      {
+        memcpy( &deviceUUID, deviceUUID_.data(), VK_UUID_SIZE * sizeof( uint8_t ) );
+        memcpy( &driverUUID, driverUUID_.data(), VK_UUID_SIZE * sizeof( uint8_t ) );
+        memcpy( &deviceLUID, deviceLUID_.data(), VK_LUID_SIZE * sizeof( uint8_t ) );
+      
+      }
 
-  struct PhysicalDeviceIDProperties
+      PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this) = rhs;
+      }
+
+      PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceIdProperties;
+      void* pNext = nullptr;
+      uint8_t deviceUUID[VK_UUID_SIZE];
+      uint8_t driverUUID[VK_UUID_SIZE];
+      uint8_t deviceLUID[VK_LUID_SIZE];
+      uint32_t deviceNodeMask;
+      vk::Bool32 deviceLUIDValid;
+    };
+    static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceIDProperties : public layout::PhysicalDeviceIDProperties
   {
     operator VkPhysicalDeviceIDProperties const&() const
     {
@@ -39238,34 +45946,60 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceIdProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint8_t deviceUUID[VK_UUID_SIZE];
-    uint8_t driverUUID[VK_UUID_SIZE];
-    uint8_t deviceLUID[VK_LUID_SIZE];
-    uint32_t deviceNodeMask;
-    Bool32 deviceLUIDValid;
+    using layout::PhysicalDeviceIDProperties::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceImageDrmFormatModifierInfoEXT
+    {
+    protected:
+      PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
+                                                   vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+                                                   uint32_t queueFamilyIndexCount_ = 0,
+                                                   const uint32_t* pQueueFamilyIndices_ = nullptr )
+        : drmFormatModifier( drmFormatModifier_ )
+        , sharingMode( sharingMode_ )
+        , queueFamilyIndexCount( queueFamilyIndexCount_ )
+        , pQueueFamilyIndices( pQueueFamilyIndices_ )
+      {}
 
-  struct PhysicalDeviceImageDrmFormatModifierInfoEXT
+      PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
+      const void* pNext = nullptr;
+      uint64_t drmFormatModifier;
+      vk::SharingMode sharingMode;
+      uint32_t queueFamilyIndexCount;
+      const uint32_t* pQueueFamilyIndices;
+    };
+    static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceImageDrmFormatModifierInfoEXT : public layout::PhysicalDeviceImageDrmFormatModifierInfoEXT
   {
     PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
-                                                 SharingMode sharingMode_ = SharingMode::eExclusive,
+                                                 vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
                                                  uint32_t queueFamilyIndexCount_ = 0,
                                                  const uint32_t* pQueueFamilyIndices_ = nullptr )
-      : drmFormatModifier( drmFormatModifier_ )
-      , sharingMode( sharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
+      : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( drmFormatModifier_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ )
     {}
 
     PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( rhs )
+    {}
 
     PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
     {
@@ -39285,7 +46019,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode( SharingMode sharingMode_ )
+    PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode( vk::SharingMode sharingMode_ )
     {
       sharingMode = sharingMode_;
       return *this;
@@ -39329,35 +46063,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint64_t drmFormatModifier;
-    SharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
+    using layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::sType;
   };
   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!" );
 
-  struct PhysicalDeviceImageFormatInfo2
+  namespace layout
   {
-    PhysicalDeviceImageFormatInfo2( Format format_ = Format::eUndefined,
-                                    ImageType type_ = ImageType::e1D,
-                                    ImageTiling tiling_ = ImageTiling::eOptimal,
-                                    ImageUsageFlags usage_ = ImageUsageFlags(),
-                                    ImageCreateFlags flags_ = ImageCreateFlags() )
-      : format( format_ )
-      , type( type_ )
-      , tiling( tiling_ )
-      , usage( usage_ )
-      , flags( flags_ )
+    struct PhysicalDeviceImageFormatInfo2
+    {
+    protected:
+      PhysicalDeviceImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined,
+                                      vk::ImageType type_ = vk::ImageType::e1D,
+                                      vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal,
+                                      vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+                                      vk::ImageCreateFlags flags_ = vk::ImageCreateFlags() )
+        : format( format_ )
+        , type( type_ )
+        , tiling( tiling_ )
+        , usage( usage_ )
+        , flags( flags_ )
+      {}
+
+      PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this) = rhs;
+      }
+
+      PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2;
+      const void* pNext = nullptr;
+      vk::Format format;
+      vk::ImageType type;
+      vk::ImageTiling tiling;
+      vk::ImageUsageFlags usage;
+      vk::ImageCreateFlags flags;
+    };
+    static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceImageFormatInfo2 : public layout::PhysicalDeviceImageFormatInfo2
+  {
+    PhysicalDeviceImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined,
+                                    vk::ImageType type_ = vk::ImageType::e1D,
+                                    vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal,
+                                    vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+                                    vk::ImageCreateFlags flags_ = vk::ImageCreateFlags() )
+      : layout::PhysicalDeviceImageFormatInfo2( format_, type_, tiling_, usage_, flags_ )
     {}
 
     PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceImageFormatInfo2( rhs )
+    {}
 
     PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs )
     {
@@ -39371,31 +46134,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2 & setFormat( Format format_ )
+    PhysicalDeviceImageFormatInfo2 & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2 & setType( ImageType type_ )
+    PhysicalDeviceImageFormatInfo2 & setType( vk::ImageType type_ )
     {
       type = type_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2 & setTiling( ImageTiling tiling_ )
+    PhysicalDeviceImageFormatInfo2 & setTiling( vk::ImageTiling tiling_ )
     {
       tiling = tiling_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2 & setUsage( ImageUsageFlags usage_ )
+    PhysicalDeviceImageFormatInfo2 & setUsage( vk::ImageUsageFlags usage_ )
     {
       usage = usage_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2 & setFlags( ImageCreateFlags flags_ )
+    PhysicalDeviceImageFormatInfo2 & setFlags( vk::ImageCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -39428,28 +46191,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    Format format;
-    ImageType type;
-    ImageTiling tiling;
-    ImageUsageFlags usage;
-    ImageCreateFlags flags;
+    using layout::PhysicalDeviceImageFormatInfo2::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceImageViewImageFormatInfoEXT
+    {
+    protected:
+      PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D )
+        : imageViewType( imageViewType_ )
+      {}
+
+      PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT;
+      void* pNext = nullptr;
+      vk::ImageViewType imageViewType;
+    };
+    static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceImageViewImageFormatInfoEXT
+  struct PhysicalDeviceImageViewImageFormatInfoEXT : public layout::PhysicalDeviceImageViewImageFormatInfoEXT
   {
-    PhysicalDeviceImageViewImageFormatInfoEXT( ImageViewType imageViewType_ = ImageViewType::e1D )
-      : imageViewType( imageViewType_ )
+    PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D )
+      : layout::PhysicalDeviceImageViewImageFormatInfoEXT( imageViewType_ )
     {}
 
     PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceImageViewImageFormatInfoEXT( rhs )
+    {}
 
     PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs )
     {
@@ -39463,7 +46246,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceImageViewImageFormatInfoEXT & setImageViewType( ImageViewType imageViewType_ )
+    PhysicalDeviceImageViewImageFormatInfoEXT & setImageViewType( vk::ImageViewType imageViewType_ )
     {
       imageViewType = imageViewType_;
       return *this;
@@ -39492,24 +46275,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT;
-
-  public:
-    void* pNext = nullptr;
-    ImageViewType imageViewType;
+    using layout::PhysicalDeviceImageViewImageFormatInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceImagelessFramebufferFeaturesKHR
+    {
+    protected:
+      PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 )
+        : imagelessFramebuffer( imagelessFramebuffer_ )
+      {}
+
+      PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
+      }
+
+      PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceImagelessFramebufferFeaturesKHR
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR;
+      void* pNext = nullptr;
+      vk::Bool32 imagelessFramebuffer;
+    };
+    static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceImagelessFramebufferFeaturesKHR : public layout::PhysicalDeviceImagelessFramebufferFeaturesKHR
   {
-    PhysicalDeviceImagelessFramebufferFeaturesKHR( Bool32 imagelessFramebuffer_ = 0 )
-      : imagelessFramebuffer( imagelessFramebuffer_ )
+    PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 )
+      : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( imagelessFramebuffer_ )
     {}
 
     PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( rhs )
+    {}
 
     PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
     {
@@ -39523,7 +46330,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceImagelessFramebufferFeaturesKHR & setImagelessFramebuffer( Bool32 imagelessFramebuffer_ )
+    PhysicalDeviceImagelessFramebufferFeaturesKHR & setImagelessFramebuffer( vk::Bool32 imagelessFramebuffer_ )
     {
       imagelessFramebuffer = imagelessFramebuffer_;
       return *this;
@@ -39552,27 +46359,137 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 imagelessFramebuffer;
+    using layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::sType;
   };
   static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceImagelessFramebufferFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceIndexTypeUint8FeaturesEXT
+    {
+    protected:
+      PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 )
+        : indexTypeUint8( indexTypeUint8_ )
+      {}
 
-  struct PhysicalDeviceInlineUniformBlockFeaturesEXT
+      PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 indexTypeUint8;
+    };
+    static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceIndexTypeUint8FeaturesEXT : public layout::PhysicalDeviceIndexTypeUint8FeaturesEXT
   {
-    PhysicalDeviceInlineUniformBlockFeaturesEXT( Bool32 inlineUniformBlock_ = 0,
-                                                 Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 )
-      : inlineUniformBlock( inlineUniformBlock_ )
-      , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ )
+    PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 )
+      : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( indexTypeUint8_ )
     {}
 
-    PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
+    PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs )
+      : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( rhs )
+    {}
+
+    PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs )
     {
-      *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this) = rhs;
+      *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(this) = rhs;
+      return *this;
+    }
+
+    PhysicalDeviceIndexTypeUint8FeaturesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceIndexTypeUint8FeaturesEXT & setIndexTypeUint8( vk::Bool32 indexTypeUint8_ )
+    {
+      indexTypeUint8 = indexTypeUint8_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( indexTypeUint8 == rhs.indexTypeUint8 );
+    }
+
+    bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
     }
 
+  private:
+    using layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceInlineUniformBlockFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0,
+                                                   vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 )
+        : inlineUniformBlock( inlineUniformBlock_ )
+        , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ )
+      {}
+
+      PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 inlineUniformBlock;
+      vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+    };
+    static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceInlineUniformBlockFeaturesEXT : public layout::PhysicalDeviceInlineUniformBlockFeaturesEXT
+  {
+    PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0,
+                                                 vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 )
+      : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( inlineUniformBlock_, descriptorBindingInlineUniformBlockUpdateAfterBind_ )
+    {}
+
+    PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
+      : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( rhs )
+    {}
+
     PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
     {
       *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this) = rhs;
@@ -39585,13 +46502,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceInlineUniformBlockFeaturesEXT & setInlineUniformBlock( Bool32 inlineUniformBlock_ )
+    PhysicalDeviceInlineUniformBlockFeaturesEXT & setInlineUniformBlock( vk::Bool32 inlineUniformBlock_ )
     {
       inlineUniformBlock = inlineUniformBlock_;
       return *this;
     }
 
-    PhysicalDeviceInlineUniformBlockFeaturesEXT & setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ )
+    PhysicalDeviceInlineUniformBlockFeaturesEXT & setDescriptorBindingInlineUniformBlockUpdateAfterBind( vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ )
     {
       descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_;
       return *this;
@@ -39621,16 +46538,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 inlineUniformBlock;
-    Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+    using layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceInlineUniformBlockPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceInlineUniformBlockPropertiesEXT( uint32_t maxInlineUniformBlockSize_ = 0,
+                                                     uint32_t maxPerStageDescriptorInlineUniformBlocks_ = 0,
+                                                     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = 0,
+                                                     uint32_t maxDescriptorSetInlineUniformBlocks_ = 0,
+                                                     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ = 0 )
+        : maxInlineUniformBlockSize( maxInlineUniformBlockSize_ )
+        , maxPerStageDescriptorInlineUniformBlocks( maxPerStageDescriptorInlineUniformBlocks_ )
+        , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ )
+        , maxDescriptorSetInlineUniformBlocks( maxDescriptorSetInlineUniformBlocks_ )
+        , maxDescriptorSetUpdateAfterBindInlineUniformBlocks( maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ )
+      {}
+
+      PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceInlineUniformBlockPropertiesEXT
+      PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t maxInlineUniformBlockSize;
+      uint32_t maxPerStageDescriptorInlineUniformBlocks;
+      uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+      uint32_t maxDescriptorSetInlineUniformBlocks;
+      uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    };
+    static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceInlineUniformBlockPropertiesEXT : public layout::PhysicalDeviceInlineUniformBlockPropertiesEXT
   {
     operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const
     {
@@ -39659,17 +46612,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxInlineUniformBlockSize;
-    uint32_t maxPerStageDescriptorInlineUniformBlocks;
-    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
-    uint32_t maxDescriptorSetInlineUniformBlocks;
-    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    using layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::sType;
   };
   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!" );
 
   struct PhysicalDeviceLimits
   {
@@ -39798,6 +46744,7 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t maxImageDimension1D;
     uint32_t maxImageDimension2D;
     uint32_t maxImageDimension3D;
@@ -39809,8 +46756,8 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxPushConstantsSize;
     uint32_t maxMemoryAllocationCount;
     uint32_t maxSamplerAllocationCount;
-    DeviceSize bufferImageGranularity;
-    DeviceSize sparseAddressSpaceSize;
+    vk::DeviceSize bufferImageGranularity;
+    vk::DeviceSize sparseAddressSpaceSize;
     uint32_t maxBoundDescriptorSets;
     uint32_t maxPerStageDescriptorSamplers;
     uint32_t maxPerStageDescriptorUniformBuffers;
@@ -39865,9 +46812,9 @@ namespace VULKAN_HPP_NAMESPACE
     float viewportBoundsRange[2];
     uint32_t viewportSubPixelBits;
     size_t minMemoryMapAlignment;
-    DeviceSize minTexelBufferOffsetAlignment;
-    DeviceSize minUniformBufferOffsetAlignment;
-    DeviceSize minStorageBufferOffsetAlignment;
+    vk::DeviceSize minTexelBufferOffsetAlignment;
+    vk::DeviceSize minUniformBufferOffsetAlignment;
+    vk::DeviceSize minStorageBufferOffsetAlignment;
     int32_t minTexelOffset;
     uint32_t maxTexelOffset;
     int32_t minTexelGatherOffset;
@@ -39878,18 +46825,18 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t maxFramebufferWidth;
     uint32_t maxFramebufferHeight;
     uint32_t maxFramebufferLayers;
-    SampleCountFlags framebufferColorSampleCounts;
-    SampleCountFlags framebufferDepthSampleCounts;
-    SampleCountFlags framebufferStencilSampleCounts;
-    SampleCountFlags framebufferNoAttachmentsSampleCounts;
+    vk::SampleCountFlags framebufferColorSampleCounts;
+    vk::SampleCountFlags framebufferDepthSampleCounts;
+    vk::SampleCountFlags framebufferStencilSampleCounts;
+    vk::SampleCountFlags framebufferNoAttachmentsSampleCounts;
     uint32_t maxColorAttachments;
-    SampleCountFlags sampledImageColorSampleCounts;
-    SampleCountFlags sampledImageIntegerSampleCounts;
-    SampleCountFlags sampledImageDepthSampleCounts;
-    SampleCountFlags sampledImageStencilSampleCounts;
-    SampleCountFlags storageImageSampleCounts;
+    vk::SampleCountFlags sampledImageColorSampleCounts;
+    vk::SampleCountFlags sampledImageIntegerSampleCounts;
+    vk::SampleCountFlags sampledImageDepthSampleCounts;
+    vk::SampleCountFlags sampledImageStencilSampleCounts;
+    vk::SampleCountFlags storageImageSampleCounts;
     uint32_t maxSampleMaskWords;
-    Bool32 timestampComputeAndGraphics;
+    vk::Bool32 timestampComputeAndGraphics;
     float timestampPeriod;
     uint32_t maxClipDistances;
     uint32_t maxCullDistances;
@@ -39899,15 +46846,244 @@ namespace VULKAN_HPP_NAMESPACE
     float lineWidthRange[2];
     float pointSizeGranularity;
     float lineWidthGranularity;
-    Bool32 strictLines;
-    Bool32 standardSampleLocations;
-    DeviceSize optimalBufferCopyOffsetAlignment;
-    DeviceSize optimalBufferCopyRowPitchAlignment;
-    DeviceSize nonCoherentAtomSize;
+    vk::Bool32 strictLines;
+    vk::Bool32 standardSampleLocations;
+    vk::DeviceSize optimalBufferCopyOffsetAlignment;
+    vk::DeviceSize optimalBufferCopyRowPitchAlignment;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceLineRasterizationFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0,
+                                                  vk::Bool32 bresenhamLines_ = 0,
+                                                  vk::Bool32 smoothLines_ = 0,
+                                                  vk::Bool32 stippledRectangularLines_ = 0,
+                                                  vk::Bool32 stippledBresenhamLines_ = 0,
+                                                  vk::Bool32 stippledSmoothLines_ = 0 )
+        : rectangularLines( rectangularLines_ )
+        , bresenhamLines( bresenhamLines_ )
+        , smoothLines( smoothLines_ )
+        , stippledRectangularLines( stippledRectangularLines_ )
+        , stippledBresenhamLines( stippledBresenhamLines_ )
+        , stippledSmoothLines( stippledSmoothLines_ )
+      {}
+
+      PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 rectangularLines;
+      vk::Bool32 bresenhamLines;
+      vk::Bool32 smoothLines;
+      vk::Bool32 stippledRectangularLines;
+      vk::Bool32 stippledBresenhamLines;
+      vk::Bool32 stippledSmoothLines;
+    };
+    static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceLineRasterizationFeaturesEXT : public layout::PhysicalDeviceLineRasterizationFeaturesEXT
+  {
+    PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0,
+                                                vk::Bool32 bresenhamLines_ = 0,
+                                                vk::Bool32 smoothLines_ = 0,
+                                                vk::Bool32 stippledRectangularLines_ = 0,
+                                                vk::Bool32 stippledBresenhamLines_ = 0,
+                                                vk::Bool32 stippledSmoothLines_ = 0 )
+      : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rectangularLines_, bresenhamLines_, smoothLines_, stippledRectangularLines_, stippledBresenhamLines_, stippledSmoothLines_ )
+    {}
+
+    PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs )
+      : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rhs )
+    {}
+
+    PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs )
+    {
+      *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(this) = rhs;
+      return *this;
+    }
+
+    PhysicalDeviceLineRasterizationFeaturesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceLineRasterizationFeaturesEXT & setRectangularLines( vk::Bool32 rectangularLines_ )
+    {
+      rectangularLines = rectangularLines_;
+      return *this;
+    }
+
+    PhysicalDeviceLineRasterizationFeaturesEXT & setBresenhamLines( vk::Bool32 bresenhamLines_ )
+    {
+      bresenhamLines = bresenhamLines_;
+      return *this;
+    }
+
+    PhysicalDeviceLineRasterizationFeaturesEXT & setSmoothLines( vk::Bool32 smoothLines_ )
+    {
+      smoothLines = smoothLines_;
+      return *this;
+    }
+
+    PhysicalDeviceLineRasterizationFeaturesEXT & setStippledRectangularLines( vk::Bool32 stippledRectangularLines_ )
+    {
+      stippledRectangularLines = stippledRectangularLines_;
+      return *this;
+    }
+
+    PhysicalDeviceLineRasterizationFeaturesEXT & setStippledBresenhamLines( vk::Bool32 stippledBresenhamLines_ )
+    {
+      stippledBresenhamLines = stippledBresenhamLines_;
+      return *this;
+    }
+
+    PhysicalDeviceLineRasterizationFeaturesEXT & setStippledSmoothLines( vk::Bool32 stippledSmoothLines_ )
+    {
+      stippledSmoothLines = stippledSmoothLines_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceLineRasterizationFeaturesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceLineRasterizationFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( rectangularLines == rhs.rectangularLines )
+          && ( bresenhamLines == rhs.bresenhamLines )
+          && ( smoothLines == rhs.smoothLines )
+          && ( stippledRectangularLines == rhs.stippledRectangularLines )
+          && ( stippledBresenhamLines == rhs.stippledBresenhamLines )
+          && ( stippledSmoothLines == rhs.stippledSmoothLines );
+    }
+
+    bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PhysicalDeviceLineRasterizationFeaturesEXT::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceLineRasterizationPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = 0 )
+        : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ )
+      {}
+
+      PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t lineSubPixelPrecisionBits;
+    };
+    static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceLineRasterizationPropertiesEXT : public layout::PhysicalDeviceLineRasterizationPropertiesEXT
+  {
+    operator VkPhysicalDeviceLineRasterizationPropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceLineRasterizationPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits );
+    }
+
+    bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PhysicalDeviceLineRasterizationPropertiesEXT::sType;
+  };
+  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!" );
 
-  struct PhysicalDeviceMaintenance3Properties
+  namespace layout
+  {
+    struct PhysicalDeviceMaintenance3Properties
+    {
+    protected:
+      PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = 0,
+                                            vk::DeviceSize maxMemoryAllocationSize_ = 0 )
+        : maxPerSetDescriptors( maxPerSetDescriptors_ )
+        , maxMemoryAllocationSize( maxMemoryAllocationSize_ )
+      {}
+
+      PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this) = rhs;
+      }
+
+      PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties;
+      void* pNext = nullptr;
+      uint32_t maxPerSetDescriptors;
+      vk::DeviceSize maxMemoryAllocationSize;
+    };
+    static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceMaintenance3Properties : public layout::PhysicalDeviceMaintenance3Properties
   {
     operator VkPhysicalDeviceMaintenance3Properties const&() const
     {
@@ -39933,16 +47109,45 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxPerSetDescriptors;
-    DeviceSize maxMemoryAllocationSize;
+    using layout::PhysicalDeviceMaintenance3Properties::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceMemoryBudgetPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceMemoryBudgetPropertiesEXT( std::array<vk::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapBudget_ = { { 0 } },
+                                               std::array<vk::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapUsage_ = { { 0 } } )
+      {
+        memcpy( &heapBudget, heapBudget_.data(), VK_MAX_MEMORY_HEAPS * sizeof( vk::DeviceSize ) );
+        memcpy( &heapUsage, heapUsage_.data(), VK_MAX_MEMORY_HEAPS * sizeof( vk::DeviceSize ) );
+      
+      }
+
+      PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT;
+      void* pNext = nullptr;
+      vk::DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
+      vk::DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
+    };
+    static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceMemoryBudgetPropertiesEXT
+  struct PhysicalDeviceMemoryBudgetPropertiesEXT : public layout::PhysicalDeviceMemoryBudgetPropertiesEXT
   {
     operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const&() const
     {
@@ -39958,8 +47163,8 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( memcmp( heapBudget, rhs.heapBudget, VK_MAX_MEMORY_HEAPS * sizeof( DeviceSize ) ) == 0 )
-          && ( memcmp( heapUsage, rhs.heapUsage, VK_MAX_MEMORY_HEAPS * sizeof( DeviceSize ) ) == 0 );
+          && ( memcmp( heapBudget, rhs.heapBudget, VK_MAX_MEMORY_HEAPS * sizeof( vk::DeviceSize ) ) == 0 )
+          && ( memcmp( heapUsage, rhs.heapUsage, VK_MAX_MEMORY_HEAPS * sizeof( vk::DeviceSize ) ) == 0 );
     }
 
     bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const& rhs ) const
@@ -39968,25 +47173,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
-    DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
+    using layout::PhysicalDeviceMemoryBudgetPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceMemoryPriorityFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 )
+        : memoryPriority( memoryPriority_ )
+      {}
+
+      PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 memoryPriority;
+    };
+    static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceMemoryPriorityFeaturesEXT
+  struct PhysicalDeviceMemoryPriorityFeaturesEXT : public layout::PhysicalDeviceMemoryPriorityFeaturesEXT
   {
-    PhysicalDeviceMemoryPriorityFeaturesEXT( Bool32 memoryPriority_ = 0 )
-      : memoryPriority( memoryPriority_ )
+    PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 )
+      : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( memoryPriority_ )
     {}
 
     PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
     {
@@ -40000,7 +47228,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceMemoryPriorityFeaturesEXT & setMemoryPriority( Bool32 memoryPriority_ )
+    PhysicalDeviceMemoryPriorityFeaturesEXT & setMemoryPriority( vk::Bool32 memoryPriority_ )
     {
       memoryPriority = memoryPriority_;
       return *this;
@@ -40029,13 +47257,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 memoryPriority;
+    using layout::PhysicalDeviceMemoryPriorityFeaturesEXT::sType;
   };
   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!" );
 
   struct PhysicalDeviceMemoryProperties
   {
@@ -40052,9 +47277,9 @@ namespace VULKAN_HPP_NAMESPACE
     bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
     {
       return ( memoryTypeCount == rhs.memoryTypeCount )
-          && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
+          && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( vk::MemoryType ) ) == 0 )
           && ( memoryHeapCount == rhs.memoryHeapCount )
-          && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
+          && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( vk::MemoryHeap ) ) == 0 );
     }
 
     bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
@@ -40062,14 +47287,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t memoryTypeCount;
-    MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+    vk::MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
     uint32_t memoryHeapCount;
-    MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
+    vk::MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceMemoryProperties2
+    {
+    protected:
+      PhysicalDeviceMemoryProperties2( vk::PhysicalDeviceMemoryProperties memoryProperties_ = vk::PhysicalDeviceMemoryProperties() )
+        : memoryProperties( memoryProperties_ )
+      {}
+
+      PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this) = rhs;
+      }
+
+      PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
+      void* pNext = nullptr;
+      vk::PhysicalDeviceMemoryProperties memoryProperties;
+    };
+    static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceMemoryProperties2
+  struct PhysicalDeviceMemoryProperties2 : public layout::PhysicalDeviceMemoryProperties2
   {
     operator VkPhysicalDeviceMemoryProperties2 const&() const
     {
@@ -40094,26 +47349,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
-
-  public:
-    void* pNext = nullptr;
-    PhysicalDeviceMemoryProperties memoryProperties;
+    using layout::PhysicalDeviceMemoryProperties2::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceMeshShaderFeaturesNV
+    {
+    protected:
+      PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0,
+                                          vk::Bool32 meshShader_ = 0 )
+        : taskShader( taskShader_ )
+        , meshShader( meshShader_ )
+      {}
+
+      PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 taskShader;
+      vk::Bool32 meshShader;
+    };
+    static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceMeshShaderFeaturesNV
+  struct PhysicalDeviceMeshShaderFeaturesNV : public layout::PhysicalDeviceMeshShaderFeaturesNV
   {
-    PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = 0,
-                                        Bool32 meshShader_ = 0 )
-      : taskShader( taskShader_ )
-      , meshShader( meshShader_ )
+    PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0,
+                                        vk::Bool32 meshShader_ = 0 )
+      : layout::PhysicalDeviceMeshShaderFeaturesNV( taskShader_, meshShader_ )
     {}
 
     PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceMeshShaderFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
     {
@@ -40127,13 +47408,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceMeshShaderFeaturesNV & setTaskShader( Bool32 taskShader_ )
+    PhysicalDeviceMeshShaderFeaturesNV & setTaskShader( vk::Bool32 taskShader_ )
     {
       taskShader = taskShader_;
       return *this;
     }
 
-    PhysicalDeviceMeshShaderFeaturesNV & setMeshShader( Bool32 meshShader_ )
+    PhysicalDeviceMeshShaderFeaturesNV & setMeshShader( vk::Bool32 meshShader_ )
     {
       meshShader = meshShader_;
       return *this;
@@ -40163,16 +47444,78 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 taskShader;
-    Bool32 meshShader;
+    using layout::PhysicalDeviceMeshShaderFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceMeshShaderPropertiesNV
+    {
+    protected:
+      PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = 0,
+                                            uint32_t maxTaskWorkGroupInvocations_ = 0,
+                                            std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = { { 0 } },
+                                            uint32_t maxTaskTotalMemorySize_ = 0,
+                                            uint32_t maxTaskOutputCount_ = 0,
+                                            uint32_t maxMeshWorkGroupInvocations_ = 0,
+                                            std::array<uint32_t,3> const& maxMeshWorkGroupSize_ = { { 0 } },
+                                            uint32_t maxMeshTotalMemorySize_ = 0,
+                                            uint32_t maxMeshOutputVertices_ = 0,
+                                            uint32_t maxMeshOutputPrimitives_ = 0,
+                                            uint32_t maxMeshMultiviewViewCount_ = 0,
+                                            uint32_t meshOutputPerVertexGranularity_ = 0,
+                                            uint32_t meshOutputPerPrimitiveGranularity_ = 0 )
+        : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ )
+        , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
+        , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ )
+        , maxTaskOutputCount( maxTaskOutputCount_ )
+        , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
+        , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ )
+        , maxMeshOutputVertices( maxMeshOutputVertices_ )
+        , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
+        , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
+        , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
+        , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
+      {
+        memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+        memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+      
+      }
 
-  struct PhysicalDeviceMeshShaderPropertiesNV
+      PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
+      void* pNext = nullptr;
+      uint32_t maxDrawMeshTasksCount;
+      uint32_t maxTaskWorkGroupInvocations;
+      uint32_t maxTaskWorkGroupSize[3];
+      uint32_t maxTaskTotalMemorySize;
+      uint32_t maxTaskOutputCount;
+      uint32_t maxMeshWorkGroupInvocations;
+      uint32_t maxMeshWorkGroupSize[3];
+      uint32_t maxMeshTotalMemorySize;
+      uint32_t maxMeshOutputVertices;
+      uint32_t maxMeshOutputPrimitives;
+      uint32_t maxMeshMultiviewViewCount;
+      uint32_t meshOutputPerVertexGranularity;
+      uint32_t meshOutputPerPrimitiveGranularity;
+    };
+    static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceMeshShaderPropertiesNV : public layout::PhysicalDeviceMeshShaderPropertiesNV
   {
     operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const
     {
@@ -40209,40 +47552,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxDrawMeshTasksCount;
-    uint32_t maxTaskWorkGroupInvocations;
-    uint32_t maxTaskWorkGroupSize[3];
-    uint32_t maxTaskTotalMemorySize;
-    uint32_t maxTaskOutputCount;
-    uint32_t maxMeshWorkGroupInvocations;
-    uint32_t maxMeshWorkGroupSize[3];
-    uint32_t maxMeshTotalMemorySize;
-    uint32_t maxMeshOutputVertices;
-    uint32_t maxMeshOutputPrimitives;
-    uint32_t maxMeshMultiviewViewCount;
-    uint32_t meshOutputPerVertexGranularity;
-    uint32_t meshOutputPerPrimitiveGranularity;
+    using layout::PhysicalDeviceMeshShaderPropertiesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceMultiviewFeatures
+    {
+    protected:
+      PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0,
+                                       vk::Bool32 multiviewGeometryShader_ = 0,
+                                       vk::Bool32 multiviewTessellationShader_ = 0 )
+        : multiview( multiview_ )
+        , multiviewGeometryShader( multiviewGeometryShader_ )
+        , multiviewTessellationShader( multiviewTessellationShader_ )
+      {}
 
-  struct PhysicalDeviceMultiviewFeatures
+      PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this) = rhs;
+      }
+
+      PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures;
+      void* pNext = nullptr;
+      vk::Bool32 multiview;
+      vk::Bool32 multiviewGeometryShader;
+      vk::Bool32 multiviewTessellationShader;
+    };
+    static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceMultiviewFeatures : public layout::PhysicalDeviceMultiviewFeatures
   {
-    PhysicalDeviceMultiviewFeatures( Bool32 multiview_ = 0,
-                                     Bool32 multiviewGeometryShader_ = 0,
-                                     Bool32 multiviewTessellationShader_ = 0 )
-      : multiview( multiview_ )
-      , multiviewGeometryShader( multiviewGeometryShader_ )
-      , multiviewTessellationShader( multiviewTessellationShader_ )
+    PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0,
+                                     vk::Bool32 multiviewGeometryShader_ = 0,
+                                     vk::Bool32 multiviewTessellationShader_ = 0 )
+      : layout::PhysicalDeviceMultiviewFeatures( multiview_, multiviewGeometryShader_, multiviewTessellationShader_ )
     {}
 
     PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceMultiviewFeatures( rhs )
+    {}
 
     PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs )
     {
@@ -40256,19 +47615,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceMultiviewFeatures & setMultiview( Bool32 multiview_ )
+    PhysicalDeviceMultiviewFeatures & setMultiview( vk::Bool32 multiview_ )
     {
       multiview = multiview_;
       return *this;
     }
 
-    PhysicalDeviceMultiviewFeatures & setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ )
+    PhysicalDeviceMultiviewFeatures & setMultiviewGeometryShader( vk::Bool32 multiviewGeometryShader_ )
     {
       multiviewGeometryShader = multiviewGeometryShader_;
       return *this;
     }
 
-    PhysicalDeviceMultiviewFeatures & setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ )
+    PhysicalDeviceMultiviewFeatures & setMultiviewTessellationShader( vk::Bool32 multiviewTessellationShader_ )
     {
       multiviewTessellationShader = multiviewTessellationShader_;
       return *this;
@@ -40299,17 +47658,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 multiview;
-    Bool32 multiviewGeometryShader;
-    Bool32 multiviewTessellationShader;
+    using layout::PhysicalDeviceMultiviewFeatures::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
+    {
+    protected:
+      PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( vk::Bool32 perViewPositionAllComponents_ = 0 )
+        : perViewPositionAllComponents( perViewPositionAllComponents_ )
+      {}
+
+      PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this) = rhs;
+      }
+
+      PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+      void* pNext = nullptr;
+      vk::Bool32 perViewPositionAllComponents;
+    };
+    static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
+  struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : public layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
   {
     operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const
     {
@@ -40334,15 +47716,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 perViewPositionAllComponents;
+    using layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::sType;
   };
   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!" );
 
-  struct PhysicalDeviceMultiviewProperties
+  namespace layout
+  {
+    struct PhysicalDeviceMultiviewProperties
+    {
+    protected:
+      PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = 0,
+                                         uint32_t maxMultiviewInstanceIndex_ = 0 )
+        : maxMultiviewViewCount( maxMultiviewViewCount_ )
+        , maxMultiviewInstanceIndex( maxMultiviewInstanceIndex_ )
+      {}
+
+      PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this) = rhs;
+      }
+
+      PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties;
+      void* pNext = nullptr;
+      uint32_t maxMultiviewViewCount;
+      uint32_t maxMultiviewInstanceIndex;
+    };
+    static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceMultiviewProperties : public layout::PhysicalDeviceMultiviewProperties
   {
     operator VkPhysicalDeviceMultiviewProperties const&() const
     {
@@ -40368,16 +47778,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxMultiviewViewCount;
-    uint32_t maxMultiviewInstanceIndex;
+    using layout::PhysicalDeviceMultiviewProperties::sType;
   };
   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!" );
 
-  struct PhysicalDevicePCIBusInfoPropertiesEXT
+  namespace layout
+  {
+    struct PhysicalDevicePCIBusInfoPropertiesEXT
+    {
+    protected:
+      PhysicalDevicePCIBusInfoPropertiesEXT( uint32_t pciDomain_ = 0,
+                                             uint32_t pciBus_ = 0,
+                                             uint32_t pciDevice_ = 0,
+                                             uint32_t pciFunction_ = 0 )
+        : pciDomain( pciDomain_ )
+        , pciBus( pciBus_ )
+        , pciDevice( pciDevice_ )
+        , pciFunction( pciFunction_ )
+      {}
+
+      PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t pciDomain;
+      uint32_t pciBus;
+      uint32_t pciDevice;
+      uint32_t pciFunction;
+    };
+    static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDevicePCIBusInfoPropertiesEXT : public layout::PhysicalDevicePCIBusInfoPropertiesEXT
   {
     operator VkPhysicalDevicePCIBusInfoPropertiesEXT const&() const
     {
@@ -40405,18 +47848,124 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t pciDomain;
-    uint32_t pciBus;
-    uint32_t pciDevice;
-    uint32_t pciFunction;
+    using layout::PhysicalDevicePCIBusInfoPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
+    {
+    protected:
+      PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 )
+        : pipelineExecutableInfo( pipelineExecutableInfo_ )
+      {}
+
+      PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
+      }
+
+      PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDevicePointClippingProperties
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+      void* pNext = nullptr;
+      vk::Bool32 pipelineExecutableInfo;
+    };
+    static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR : public layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
+  {
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 )
+      : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( pipelineExecutableInfo_ )
+    {}
+
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs )
+      : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( rhs )
+    {}
+
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs )
+    {
+      *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
+      return *this;
+    }
+
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPipelineExecutableInfo( vk::Bool32 pipelineExecutableInfo_ )
+    {
+      pipelineExecutableInfo = pipelineExecutableInfo_;
+      return *this;
+    }
+
+    operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>( this );
+    }
+
+    operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>( this );
+    }
+
+    bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pipelineExecutableInfo == rhs.pipelineExecutableInfo );
+    }
+
+    bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDevicePointClippingProperties
+    {
+    protected:
+      PhysicalDevicePointClippingProperties( vk::PointClippingBehavior pointClippingBehavior_ = vk::PointClippingBehavior::eAllClipPlanes )
+        : pointClippingBehavior( pointClippingBehavior_ )
+      {}
+
+      PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this) = rhs;
+      }
+
+      PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
+      void* pNext = nullptr;
+      vk::PointClippingBehavior pointClippingBehavior;
+    };
+    static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDevicePointClippingProperties : public layout::PhysicalDevicePointClippingProperties
   {
     operator VkPhysicalDevicePointClippingProperties const&() const
     {
@@ -40441,13 +47990,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
-
-  public:
-    void* pNext = nullptr;
-    PointClippingBehavior pointClippingBehavior;
+    using layout::PhysicalDevicePointClippingProperties::sType;
   };
   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!" );
 
   struct PhysicalDeviceSparseProperties
   {
@@ -40475,13 +48021,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Bool32 residencyStandard2DBlockShape;
-    Bool32 residencyStandard2DMultisampleBlockShape;
-    Bool32 residencyStandard3DBlockShape;
-    Bool32 residencyAlignedMipSize;
-    Bool32 residencyNonResidentStrict;
+  public:
+    vk::Bool32 residencyStandard2DBlockShape;
+    vk::Bool32 residencyStandard2DMultisampleBlockShape;
+    vk::Bool32 residencyStandard3DBlockShape;
+    vk::Bool32 residencyAlignedMipSize;
+    vk::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
   {
@@ -40513,19 +48061,49 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t apiVersion;
     uint32_t driverVersion;
     uint32_t vendorID;
     uint32_t deviceID;
-    PhysicalDeviceType deviceType;
+    vk::PhysicalDeviceType deviceType;
     char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
     uint8_t pipelineCacheUUID[VK_UUID_SIZE];
-    PhysicalDeviceLimits limits;
-    PhysicalDeviceSparseProperties sparseProperties;
+    vk::PhysicalDeviceLimits limits;
+    vk::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
+  namespace layout
+  {
+    struct PhysicalDeviceProperties2
+    {
+    protected:
+      PhysicalDeviceProperties2( vk::PhysicalDeviceProperties properties_ = vk::PhysicalDeviceProperties() )
+        : properties( properties_ )
+      {}
+
+      PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceProperties2*>(this) = rhs;
+      }
+
+      PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceProperties2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceProperties2;
+      void* pNext = nullptr;
+      vk::PhysicalDeviceProperties properties;
+    };
+    static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceProperties2 : public layout::PhysicalDeviceProperties2
   {
     operator VkPhysicalDeviceProperties2 const&() const
     {
@@ -40550,24 +48128,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceProperties2;
-
-  public:
-    void* pNext = nullptr;
-    PhysicalDeviceProperties properties;
+    using layout::PhysicalDeviceProperties2::sType;
   };
   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!" );
 
-  struct PhysicalDeviceProtectedMemoryFeatures
+  namespace layout
   {
-    PhysicalDeviceProtectedMemoryFeatures( Bool32 protectedMemory_ = 0 )
-      : protectedMemory( protectedMemory_ )
+    struct PhysicalDeviceProtectedMemoryFeatures
+    {
+    protected:
+      PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 )
+        : protectedMemory( protectedMemory_ )
+      {}
+
+      PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this) = rhs;
+      }
+
+      PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
+      void* pNext = nullptr;
+      vk::Bool32 protectedMemory;
+    };
+    static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceProtectedMemoryFeatures : public layout::PhysicalDeviceProtectedMemoryFeatures
+  {
+    PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 )
+      : layout::PhysicalDeviceProtectedMemoryFeatures( protectedMemory_ )
     {}
 
     PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceProtectedMemoryFeatures( rhs )
+    {}
 
     PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
     {
@@ -40581,7 +48183,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceProtectedMemoryFeatures & setProtectedMemory( Bool32 protectedMemory_ )
+    PhysicalDeviceProtectedMemoryFeatures & setProtectedMemory( vk::Bool32 protectedMemory_ )
     {
       protectedMemory = protectedMemory_;
       return *this;
@@ -40610,15 +48212,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 protectedMemory;
+    using layout::PhysicalDeviceProtectedMemoryFeatures::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceProtectedMemoryProperties
+    {
+    protected:
+      PhysicalDeviceProtectedMemoryProperties( vk::Bool32 protectedNoFault_ = 0 )
+        : protectedNoFault( protectedNoFault_ )
+      {}
+
+      PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this) = rhs;
+      }
+
+      PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
+      void* pNext = nullptr;
+      vk::Bool32 protectedNoFault;
+    };
+    static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceProtectedMemoryProperties
+  struct PhysicalDeviceProtectedMemoryProperties : public layout::PhysicalDeviceProtectedMemoryProperties
   {
     operator VkPhysicalDeviceProtectedMemoryProperties const&() const
     {
@@ -40643,15 +48270,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 protectedNoFault;
+    using layout::PhysicalDeviceProtectedMemoryProperties::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDevicePushDescriptorPropertiesKHR
+    {
+    protected:
+      PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 )
+        : maxPushDescriptors( maxPushDescriptors_ )
+      {}
+
+      PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this) = rhs;
+      }
+
+      PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
+      void* pNext = nullptr;
+      uint32_t maxPushDescriptors;
+    };
+    static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDevicePushDescriptorPropertiesKHR
+  struct PhysicalDevicePushDescriptorPropertiesKHR : public layout::PhysicalDevicePushDescriptorPropertiesKHR
   {
     operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const
     {
@@ -40676,15 +48328,61 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxPushDescriptors;
+    using layout::PhysicalDevicePushDescriptorPropertiesKHR::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceRayTracingPropertiesNV
+    {
+    protected:
+      PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = 0,
+                                            uint32_t maxRecursionDepth_ = 0,
+                                            uint32_t maxShaderGroupStride_ = 0,
+                                            uint32_t shaderGroupBaseAlignment_ = 0,
+                                            uint64_t maxGeometryCount_ = 0,
+                                            uint64_t maxInstanceCount_ = 0,
+                                            uint64_t maxTriangleCount_ = 0,
+                                            uint32_t maxDescriptorSetAccelerationStructures_ = 0 )
+        : shaderGroupHandleSize( shaderGroupHandleSize_ )
+        , maxRecursionDepth( maxRecursionDepth_ )
+        , maxShaderGroupStride( maxShaderGroupStride_ )
+        , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ )
+        , maxGeometryCount( maxGeometryCount_ )
+        , maxInstanceCount( maxInstanceCount_ )
+        , maxTriangleCount( maxTriangleCount_ )
+        , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ )
+      {}
+
+      PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
+      void* pNext = nullptr;
+      uint32_t shaderGroupHandleSize;
+      uint32_t maxRecursionDepth;
+      uint32_t maxShaderGroupStride;
+      uint32_t shaderGroupBaseAlignment;
+      uint64_t maxGeometryCount;
+      uint64_t maxInstanceCount;
+      uint64_t maxTriangleCount;
+      uint32_t maxDescriptorSetAccelerationStructures;
+    };
+    static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceRayTracingPropertiesNV
+  struct PhysicalDeviceRayTracingPropertiesNV : public layout::PhysicalDeviceRayTracingPropertiesNV
   {
     operator VkPhysicalDeviceRayTracingPropertiesNV const&() const
     {
@@ -40716,31 +48414,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t shaderGroupHandleSize;
-    uint32_t maxRecursionDepth;
-    uint32_t maxShaderGroupStride;
-    uint32_t shaderGroupBaseAlignment;
-    uint64_t maxGeometryCount;
-    uint64_t maxInstanceCount;
-    uint64_t maxTriangleCount;
-    uint32_t maxDescriptorSetAccelerationStructures;
+    using layout::PhysicalDeviceRayTracingPropertiesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
+    {
+    protected:
+      PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 )
+        : representativeFragmentTest( representativeFragmentTest_ )
+      {}
+
+      PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 representativeFragmentTest;
+    };
+    static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
+  struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV : public layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV
   {
-    PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = 0 )
-      : representativeFragmentTest( representativeFragmentTest_ )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 )
+      : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( representativeFragmentTest_ )
     {}
 
     PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
     {
@@ -40754,7 +48469,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest( vk::Bool32 representativeFragmentTest_ )
     {
       representativeFragmentTest = representativeFragmentTest_;
       return *this;
@@ -40783,15 +48498,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 representativeFragmentTest;
+    using layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceSampleLocationsPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceSampleLocationsPropertiesEXT( vk::SampleCountFlags sampleLocationSampleCounts_ = vk::SampleCountFlags(),
+                                                  vk::Extent2D maxSampleLocationGridSize_ = vk::Extent2D(),
+                                                  std::array<float,2> const& sampleLocationCoordinateRange_ = { { 0 } },
+                                                  uint32_t sampleLocationSubPixelBits_ = 0,
+                                                  vk::Bool32 variableSampleLocations_ = 0 )
+        : sampleLocationSampleCounts( sampleLocationSampleCounts_ )
+        , maxSampleLocationGridSize( maxSampleLocationGridSize_ )
+        , sampleLocationSubPixelBits( sampleLocationSubPixelBits_ )
+        , variableSampleLocations( variableSampleLocations_ )
+      {
+        memcpy( &sampleLocationCoordinateRange, sampleLocationCoordinateRange_.data(), 2 * sizeof( float ) );
+      
+      }
+
+      PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceSampleLocationsPropertiesEXT
+      PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
+      void* pNext = nullptr;
+      vk::SampleCountFlags sampleLocationSampleCounts;
+      vk::Extent2D maxSampleLocationGridSize;
+      float sampleLocationCoordinateRange[2];
+      uint32_t sampleLocationSubPixelBits;
+      vk::Bool32 variableSampleLocations;
+    };
+    static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceSampleLocationsPropertiesEXT : public layout::PhysicalDeviceSampleLocationsPropertiesEXT
   {
     operator VkPhysicalDeviceSampleLocationsPropertiesEXT const&() const
     {
@@ -40820,19 +48574,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    SampleCountFlags sampleLocationSampleCounts;
-    Extent2D maxSampleLocationGridSize;
-    float sampleLocationCoordinateRange[2];
-    uint32_t sampleLocationSubPixelBits;
-    Bool32 variableSampleLocations;
+    using layout::PhysicalDeviceSampleLocationsPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( vk::Bool32 filterMinmaxSingleComponentFormats_ = 0,
+                                                      vk::Bool32 filterMinmaxImageComponentMapping_ = 0 )
+        : filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ )
+        , filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ )
+      {}
+
+      PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
+      PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 filterMinmaxSingleComponentFormats;
+      vk::Bool32 filterMinmaxImageComponentMapping;
+    };
+    static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT : public layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
   {
     operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const&() const
     {
@@ -40858,25 +48636,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 filterMinmaxSingleComponentFormats;
-    Bool32 filterMinmaxImageComponentMapping;
+    using layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::sType;
   };
   static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  struct PhysicalDeviceSamplerYcbcrConversionFeatures
+  namespace layout
   {
-    PhysicalDeviceSamplerYcbcrConversionFeatures( Bool32 samplerYcbcrConversion_ = 0 )
-      : samplerYcbcrConversion( samplerYcbcrConversion_ )
+    struct PhysicalDeviceSamplerYcbcrConversionFeatures
+    {
+    protected:
+      PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 )
+        : samplerYcbcrConversion( samplerYcbcrConversion_ )
+      {}
+
+      PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this) = rhs;
+      }
+
+      PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
+      void* pNext = nullptr;
+      vk::Bool32 samplerYcbcrConversion;
+    };
+    static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceSamplerYcbcrConversionFeatures : public layout::PhysicalDeviceSamplerYcbcrConversionFeatures
+  {
+    PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 )
+      : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( samplerYcbcrConversion_ )
     {}
 
     PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( rhs )
+    {}
 
     PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
     {
@@ -40890,7 +48691,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceSamplerYcbcrConversionFeatures & setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ )
+    PhysicalDeviceSamplerYcbcrConversionFeatures & setSamplerYcbcrConversion( vk::Bool32 samplerYcbcrConversion_ )
     {
       samplerYcbcrConversion = samplerYcbcrConversion_;
       return *this;
@@ -40919,24 +48720,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 samplerYcbcrConversion;
+    using layout::PhysicalDeviceSamplerYcbcrConversionFeatures::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceScalarBlockLayoutFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 )
+        : scalarBlockLayout( scalarBlockLayout_ )
+      {}
 
-  struct PhysicalDeviceScalarBlockLayoutFeaturesEXT
+      PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 scalarBlockLayout;
+    };
+    static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceScalarBlockLayoutFeaturesEXT : public layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT
   {
-    PhysicalDeviceScalarBlockLayoutFeaturesEXT( Bool32 scalarBlockLayout_ = 0 )
-      : scalarBlockLayout( scalarBlockLayout_ )
+    PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 )
+      : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( scalarBlockLayout_ )
     {}
 
     PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
     {
@@ -40950,7 +48775,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceScalarBlockLayoutFeaturesEXT & setScalarBlockLayout( Bool32 scalarBlockLayout_ )
+    PhysicalDeviceScalarBlockLayoutFeaturesEXT & setScalarBlockLayout( vk::Bool32 scalarBlockLayout_ )
     {
       scalarBlockLayout = scalarBlockLayout_;
       return *this;
@@ -40979,26 +48804,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 scalarBlockLayout;
+    using layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::sType;
   };
   static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceScalarBlockLayoutFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
+  namespace layout
   {
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR( Bool32 shaderBufferInt64Atomics_ = 0,
-                                                Bool32 shaderSharedInt64Atomics_ = 0 )
-      : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
-      , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
+    struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
+    {
+    protected:
+      PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0,
+                                                  vk::Bool32 shaderSharedInt64Atomics_ = 0 )
+        : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
+        , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
+      {}
+
+      PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR;
+      void* pNext = nullptr;
+      vk::Bool32 shaderBufferInt64Atomics;
+      vk::Bool32 shaderSharedInt64Atomics;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShaderAtomicInt64FeaturesKHR : public layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR
+  {
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0,
+                                                vk::Bool32 shaderSharedInt64Atomics_ = 0 )
+      : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( shaderBufferInt64Atomics_, shaderSharedInt64Atomics_ )
     {}
 
     PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( rhs )
+    {}
 
     PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
     {
@@ -41012,13 +48863,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ )
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderBufferInt64Atomics( vk::Bool32 shaderBufferInt64Atomics_ )
     {
       shaderBufferInt64Atomics = shaderBufferInt64Atomics_;
       return *this;
     }
 
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ )
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderSharedInt64Atomics( vk::Bool32 shaderSharedInt64Atomics_ )
     {
       shaderSharedInt64Atomics = shaderSharedInt64Atomics_;
       return *this;
@@ -41048,16 +48899,141 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderBufferInt64Atomics;
-    Bool32 shaderSharedInt64Atomics;
+    using layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::sType;
   };
   static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceShaderAtomicInt64FeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShaderCoreProperties2AMD
+    {
+    protected:
+      PhysicalDeviceShaderCoreProperties2AMD( vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = vk::ShaderCorePropertiesFlagsAMD(),
+                                              uint32_t activeComputeUnitCount_ = 0 )
+        : shaderCoreFeatures( shaderCoreFeatures_ )
+        , activeComputeUnitCount( activeComputeUnitCount_ )
+      {}
+
+      PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD;
+      void* pNext = nullptr;
+      vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures;
+      uint32_t activeComputeUnitCount;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShaderCoreProperties2AMD : public layout::PhysicalDeviceShaderCoreProperties2AMD
+  {
+    operator VkPhysicalDeviceShaderCoreProperties2AMD const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>( this );
+    }
+
+    operator VkPhysicalDeviceShaderCoreProperties2AMD &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>( this );
+    }
+
+    bool operator==( PhysicalDeviceShaderCoreProperties2AMD const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shaderCoreFeatures == rhs.shaderCoreFeatures )
+          && ( activeComputeUnitCount == rhs.activeComputeUnitCount );
+    }
+
+    bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PhysicalDeviceShaderCoreProperties2AMD::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShaderCorePropertiesAMD
+    {
+    protected:
+      PhysicalDeviceShaderCorePropertiesAMD( uint32_t shaderEngineCount_ = 0,
+                                             uint32_t shaderArraysPerEngineCount_ = 0,
+                                             uint32_t computeUnitsPerShaderArray_ = 0,
+                                             uint32_t simdPerComputeUnit_ = 0,
+                                             uint32_t wavefrontsPerSimd_ = 0,
+                                             uint32_t wavefrontSize_ = 0,
+                                             uint32_t sgprsPerSimd_ = 0,
+                                             uint32_t minSgprAllocation_ = 0,
+                                             uint32_t maxSgprAllocation_ = 0,
+                                             uint32_t sgprAllocationGranularity_ = 0,
+                                             uint32_t vgprsPerSimd_ = 0,
+                                             uint32_t minVgprAllocation_ = 0,
+                                             uint32_t maxVgprAllocation_ = 0,
+                                             uint32_t vgprAllocationGranularity_ = 0 )
+        : shaderEngineCount( shaderEngineCount_ )
+        , shaderArraysPerEngineCount( shaderArraysPerEngineCount_ )
+        , computeUnitsPerShaderArray( computeUnitsPerShaderArray_ )
+        , simdPerComputeUnit( simdPerComputeUnit_ )
+        , wavefrontsPerSimd( wavefrontsPerSimd_ )
+        , wavefrontSize( wavefrontSize_ )
+        , sgprsPerSimd( sgprsPerSimd_ )
+        , minSgprAllocation( minSgprAllocation_ )
+        , maxSgprAllocation( maxSgprAllocation_ )
+        , sgprAllocationGranularity( sgprAllocationGranularity_ )
+        , vgprsPerSimd( vgprsPerSimd_ )
+        , minVgprAllocation( minVgprAllocation_ )
+        , maxVgprAllocation( maxVgprAllocation_ )
+        , vgprAllocationGranularity( vgprAllocationGranularity_ )
+      {}
+
+      PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD;
+      void* pNext = nullptr;
+      uint32_t shaderEngineCount;
+      uint32_t shaderArraysPerEngineCount;
+      uint32_t computeUnitsPerShaderArray;
+      uint32_t simdPerComputeUnit;
+      uint32_t wavefrontsPerSimd;
+      uint32_t wavefrontSize;
+      uint32_t sgprsPerSimd;
+      uint32_t minSgprAllocation;
+      uint32_t maxSgprAllocation;
+      uint32_t sgprAllocationGranularity;
+      uint32_t vgprsPerSimd;
+      uint32_t minVgprAllocation;
+      uint32_t maxVgprAllocation;
+      uint32_t vgprAllocationGranularity;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceShaderCorePropertiesAMD
+  struct PhysicalDeviceShaderCorePropertiesAMD : public layout::PhysicalDeviceShaderCorePropertiesAMD
   {
     operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const
     {
@@ -41095,37 +49071,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t shaderEngineCount;
-    uint32_t shaderArraysPerEngineCount;
-    uint32_t computeUnitsPerShaderArray;
-    uint32_t simdPerComputeUnit;
-    uint32_t wavefrontsPerSimd;
-    uint32_t wavefrontSize;
-    uint32_t sgprsPerSimd;
-    uint32_t minSgprAllocation;
-    uint32_t maxSgprAllocation;
-    uint32_t sgprAllocationGranularity;
-    uint32_t vgprsPerSimd;
-    uint32_t minVgprAllocation;
-    uint32_t maxVgprAllocation;
-    uint32_t vgprAllocationGranularity;
+    using layout::PhysicalDeviceShaderCorePropertiesAMD::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 )
+        : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ )
+      {}
+
+      PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 shaderDemoteToHelperInvocation;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
+  struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT : public layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
   {
-    PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( Bool32 shaderDemoteToHelperInvocation_ = 0 )
-      : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ )
+    PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 )
+      : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( shaderDemoteToHelperInvocation_ )
     {}
 
     PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs )
     {
@@ -41139,7 +49126,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ )
+    PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & setShaderDemoteToHelperInvocation( vk::Bool32 shaderDemoteToHelperInvocation_ )
     {
       shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_;
       return *this;
@@ -41168,24 +49155,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderDemoteToHelperInvocation;
+    using layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShaderDrawParametersFeatures
+    {
+    protected:
+      PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 )
+        : shaderDrawParameters( shaderDrawParameters_ )
+      {}
+
+      PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceShaderDrawParametersFeatures
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures;
+      void* pNext = nullptr;
+      vk::Bool32 shaderDrawParameters;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShaderDrawParametersFeatures : public layout::PhysicalDeviceShaderDrawParametersFeatures
   {
-    PhysicalDeviceShaderDrawParametersFeatures( Bool32 shaderDrawParameters_ = 0 )
-      : shaderDrawParameters( shaderDrawParameters_ )
+    PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 )
+      : layout::PhysicalDeviceShaderDrawParametersFeatures( shaderDrawParameters_ )
     {}
 
     PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceShaderDrawParametersFeatures( rhs )
+    {}
 
     PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs )
     {
@@ -41199,7 +49210,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceShaderDrawParametersFeatures & setShaderDrawParameters( Bool32 shaderDrawParameters_ )
+    PhysicalDeviceShaderDrawParametersFeatures & setShaderDrawParameters( vk::Bool32 shaderDrawParameters_ )
     {
       shaderDrawParameters = shaderDrawParameters_;
       return *this;
@@ -41228,25 +49239,144 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderDrawParameters;
+    using layout::PhysicalDeviceShaderDrawParametersFeatures::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShaderFloat16Int8FeaturesKHR
+    {
+    protected:
+      PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0,
+                                                  vk::Bool32 shaderInt8_ = 0 )
+        : shaderFloat16( shaderFloat16_ )
+        , shaderInt8( shaderInt8_ )
+      {}
 
-  struct PhysicalDeviceShaderImageFootprintFeaturesNV
+      PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR;
+      void* pNext = nullptr;
+      vk::Bool32 shaderFloat16;
+      vk::Bool32 shaderInt8;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShaderFloat16Int8FeaturesKHR : public layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR
   {
-    PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = 0 )
-      : imageFootprint( imageFootprint_ )
+    PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0,
+                                                vk::Bool32 shaderInt8_ = 0 )
+      : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( shaderFloat16_, shaderInt8_ )
     {}
 
-    PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+    PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs )
+      : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( rhs )
+    {}
+
+    PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs )
     {
-      *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this) = rhs;
+      *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>(this) = rhs;
+      return *this;
+    }
+
+    PhysicalDeviceShaderFloat16Int8FeaturesKHR & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderFloat16Int8FeaturesKHR & setShaderFloat16( vk::Bool32 shaderFloat16_ )
+    {
+      shaderFloat16 = shaderFloat16_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderFloat16Int8FeaturesKHR & setShaderInt8( vk::Bool32 shaderInt8_ )
+    {
+      shaderInt8 = shaderInt8_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>( this );
+    }
+
+    operator VkPhysicalDeviceShaderFloat16Int8FeaturesKHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>( this );
+    }
+
+    bool operator==( PhysicalDeviceShaderFloat16Int8FeaturesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shaderFloat16 == rhs.shaderFloat16 )
+          && ( shaderInt8 == rhs.shaderInt8 );
     }
 
+    bool operator!=( PhysicalDeviceShaderFloat16Int8FeaturesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::sType;
+  };
+  static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceShaderFloat16Int8FeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShaderImageFootprintFeaturesNV
+    {
+    protected:
+      PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 )
+        : imageFootprint( imageFootprint_ )
+      {}
+
+      PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 imageFootprint;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShaderImageFootprintFeaturesNV : public layout::PhysicalDeviceShaderImageFootprintFeaturesNV
+  {
+    PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 )
+      : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( imageFootprint_ )
+    {}
+
+    PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+      : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( rhs )
+    {}
+
     PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
     {
       *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this) = rhs;
@@ -41259,7 +49389,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint( Bool32 imageFootprint_ )
+    PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint( vk::Bool32 imageFootprint_ )
     {
       imageFootprint = imageFootprint_;
       return *this;
@@ -41288,84 +49418,132 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 imageFootprint;
+    using layout::PhysicalDeviceShaderImageFootprintFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
+    {
+    protected:
+      PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 )
+        : shaderIntegerFunctions2( shaderIntegerFunctions2_ )
+      {}
+
+      PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
+      void* pNext = nullptr;
+      vk::Bool32 shaderIntegerFunctions2;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceShaderIntegerFunctions2INTEL
+  struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : public layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
   {
-    PhysicalDeviceShaderIntegerFunctions2INTEL( Bool32 shaderIntegerFunctions2_ = 0 )
-      : shaderIntegerFunctions2( shaderIntegerFunctions2_ )
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 )
+      : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( shaderIntegerFunctions2_ )
     {}
 
-    PhysicalDeviceShaderIntegerFunctions2INTEL( VkPhysicalDeviceShaderIntegerFunctions2INTEL const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2INTEL*>(this) = rhs;
-    }
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs )
+      : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( rhs )
+    {}
 
-    PhysicalDeviceShaderIntegerFunctions2INTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2INTEL const & rhs )
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs )
     {
-      *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2INTEL*>(this) = rhs;
+      *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this) = rhs;
       return *this;
     }
 
-    PhysicalDeviceShaderIntegerFunctions2INTEL & setPNext( void* pNext_ )
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceShaderIntegerFunctions2INTEL & setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ )
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setShaderIntegerFunctions2( vk::Bool32 shaderIntegerFunctions2_ )
     {
       shaderIntegerFunctions2 = shaderIntegerFunctions2_;
       return *this;
     }
 
-    operator VkPhysicalDeviceShaderIntegerFunctions2INTEL const&() const
+    operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2INTEL*>( this );
+      return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>( this );
     }
 
-    operator VkPhysicalDeviceShaderIntegerFunctions2INTEL &()
+    operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2INTEL*>( this );
+      return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>( this );
     }
 
-    bool operator==( PhysicalDeviceShaderIntegerFunctions2INTEL const& rhs ) const
+    bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
           && ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 );
     }
 
-    bool operator!=( PhysicalDeviceShaderIntegerFunctions2INTEL const& rhs ) const
+    bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderIntegerFunctions2;
+    using layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::sType;
   };
-  static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2INTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2INTEL ), "struct and wrapper have different size!" );
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
+    {
+    protected:
+      PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 )
+        : shaderSMBuiltins( shaderSMBuiltins_ )
+      {}
+
+      PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 shaderSMBuiltins;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShaderSMBuiltinsFeaturesNV : public layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV
   {
-    PhysicalDeviceShaderSMBuiltinsFeaturesNV( Bool32 shaderSMBuiltins_ = 0 )
-      : shaderSMBuiltins( shaderSMBuiltins_ )
+    PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 )
+      : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( shaderSMBuiltins_ )
     {}
 
     PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs )
     {
@@ -41379,7 +49557,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceShaderSMBuiltinsFeaturesNV & setShaderSMBuiltins( Bool32 shaderSMBuiltins_ )
+    PhysicalDeviceShaderSMBuiltinsFeaturesNV & setShaderSMBuiltins( vk::Bool32 shaderSMBuiltins_ )
     {
       shaderSMBuiltins = shaderSMBuiltins_;
       return *this;
@@ -41408,15 +49586,43 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderSMBuiltins;
+    using layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::sType;
   };
   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!" );
 
-  struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
+  namespace layout
+  {
+    struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
+    {
+    protected:
+      PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = 0,
+                                                  uint32_t shaderWarpsPerSM_ = 0 )
+        : shaderSMCount( shaderSMCount_ )
+        , shaderWarpsPerSM( shaderWarpsPerSM_ )
+      {}
+
+      PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV;
+      void* pNext = nullptr;
+      uint32_t shaderSMCount;
+      uint32_t shaderWarpsPerSM;
+    };
+    static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShaderSMBuiltinsPropertiesNV : public layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV
   {
     operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const&() const
     {
@@ -41442,27 +49648,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t shaderSMCount;
-    uint32_t shaderWarpsPerSM;
+    using layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShadingRateImageFeaturesNV
+    {
+    protected:
+      PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0,
+                                                vk::Bool32 shadingRateCoarseSampleOrder_ = 0 )
+        : shadingRateImage( shadingRateImage_ )
+        , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
+      {}
 
-  struct PhysicalDeviceShadingRateImageFeaturesNV
+      PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
+      void* pNext = nullptr;
+      vk::Bool32 shadingRateImage;
+      vk::Bool32 shadingRateCoarseSampleOrder;
+    };
+    static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShadingRateImageFeaturesNV : public layout::PhysicalDeviceShadingRateImageFeaturesNV
   {
-    PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = 0,
-                                              Bool32 shadingRateCoarseSampleOrder_ = 0 )
-      : shadingRateImage( shadingRateImage_ )
-      , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
+    PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0,
+                                              vk::Bool32 shadingRateCoarseSampleOrder_ = 0 )
+      : layout::PhysicalDeviceShadingRateImageFeaturesNV( shadingRateImage_, shadingRateCoarseSampleOrder_ )
     {}
 
     PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceShadingRateImageFeaturesNV( rhs )
+    {}
 
     PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
     {
@@ -41476,13 +49707,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage( Bool32 shadingRateImage_ )
+    PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage( vk::Bool32 shadingRateImage_ )
     {
       shadingRateImage = shadingRateImage_;
       return *this;
     }
 
-    PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ )
+    PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder( vk::Bool32 shadingRateCoarseSampleOrder_ )
     {
       shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_;
       return *this;
@@ -41512,16 +49743,46 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shadingRateImage;
-    Bool32 shadingRateCoarseSampleOrder;
+    using layout::PhysicalDeviceShadingRateImageFeaturesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceShadingRateImagePropertiesNV
+    {
+    protected:
+      PhysicalDeviceShadingRateImagePropertiesNV( vk::Extent2D shadingRateTexelSize_ = vk::Extent2D(),
+                                                  uint32_t shadingRatePaletteSize_ = 0,
+                                                  uint32_t shadingRateMaxCoarseSamples_ = 0 )
+        : shadingRateTexelSize( shadingRateTexelSize_ )
+        , shadingRatePaletteSize( shadingRatePaletteSize_ )
+        , shadingRateMaxCoarseSamples( shadingRateMaxCoarseSamples_ )
+      {}
 
-  struct PhysicalDeviceShadingRateImagePropertiesNV
+      PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this) = rhs;
+      }
+
+      PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
+      void* pNext = nullptr;
+      vk::Extent2D shadingRateTexelSize;
+      uint32_t shadingRatePaletteSize;
+      uint32_t shadingRateMaxCoarseSamples;
+    };
+    static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceShadingRateImagePropertiesNV : public layout::PhysicalDeviceShadingRateImagePropertiesNV
   {
     operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const
     {
@@ -41548,34 +49809,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    Extent2D shadingRateTexelSize;
-    uint32_t shadingRatePaletteSize;
-    uint32_t shadingRateMaxCoarseSamples;
+    using layout::PhysicalDeviceShadingRateImagePropertiesNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceSparseImageFormatInfo2
+    {
+    protected:
+      PhysicalDeviceSparseImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined,
+                                            vk::ImageType type_ = vk::ImageType::e1D,
+                                            vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+                                            vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+                                            vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal )
+        : format( format_ )
+        , type( type_ )
+        , samples( samples_ )
+        , usage( usage_ )
+        , tiling( tiling_ )
+      {}
 
-  struct PhysicalDeviceSparseImageFormatInfo2
+      PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this) = rhs;
+      }
+
+      PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
+      const void* pNext = nullptr;
+      vk::Format format;
+      vk::ImageType type;
+      vk::SampleCountFlagBits samples;
+      vk::ImageUsageFlags usage;
+      vk::ImageTiling tiling;
+    };
+    static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceSparseImageFormatInfo2 : public layout::PhysicalDeviceSparseImageFormatInfo2
   {
-    PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined,
-                                          ImageType type_ = ImageType::e1D,
-                                          SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
-                                          ImageUsageFlags usage_ = ImageUsageFlags(),
-                                          ImageTiling tiling_ = ImageTiling::eOptimal )
-      : format( format_ )
-      , type( type_ )
-      , samples( samples_ )
-      , usage( usage_ )
-      , tiling( tiling_ )
+    PhysicalDeviceSparseImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined,
+                                          vk::ImageType type_ = vk::ImageType::e1D,
+                                          vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+                                          vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+                                          vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal )
+      : layout::PhysicalDeviceSparseImageFormatInfo2( format_, type_, samples_, usage_, tiling_ )
     {}
 
     PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceSparseImageFormatInfo2( rhs )
+    {}
 
     PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
     {
@@ -41589,31 +49880,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceSparseImageFormatInfo2 & setFormat( Format format_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    PhysicalDeviceSparseImageFormatInfo2 & setType( ImageType type_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setType( vk::ImageType type_ )
     {
       type = type_;
       return *this;
     }
 
-    PhysicalDeviceSparseImageFormatInfo2 & setSamples( SampleCountFlagBits samples_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setSamples( vk::SampleCountFlagBits samples_ )
     {
       samples = samples_;
       return *this;
     }
 
-    PhysicalDeviceSparseImageFormatInfo2 & setUsage( ImageUsageFlags usage_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setUsage( vk::ImageUsageFlags usage_ )
     {
       usage = usage_;
       return *this;
     }
 
-    PhysicalDeviceSparseImageFormatInfo2 & setTiling( ImageTiling tiling_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setTiling( vk::ImageTiling tiling_ )
     {
       tiling = tiling_;
       return *this;
@@ -41646,19 +49937,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    Format format;
-    ImageType type;
-    SampleCountFlagBits samples;
-    ImageUsageFlags usage;
-    ImageTiling tiling;
+    using layout::PhysicalDeviceSparseImageFormatInfo2::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceSubgroupProperties
+    {
+    protected:
+      PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = 0,
+                                        vk::ShaderStageFlags supportedStages_ = vk::ShaderStageFlags(),
+                                        vk::SubgroupFeatureFlags supportedOperations_ = vk::SubgroupFeatureFlags(),
+                                        vk::Bool32 quadOperationsInAllStages_ = 0 )
+        : subgroupSize( subgroupSize_ )
+        , supportedStages( supportedStages_ )
+        , supportedOperations( supportedOperations_ )
+        , quadOperationsInAllStages( quadOperationsInAllStages_ )
+      {}
+
+      PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this) = rhs;
+      }
+
+      PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties;
+      void* pNext = nullptr;
+      uint32_t subgroupSize;
+      vk::ShaderStageFlags supportedStages;
+      vk::SubgroupFeatureFlags supportedOperations;
+      vk::Bool32 quadOperationsInAllStages;
+    };
+    static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceSubgroupProperties
+  struct PhysicalDeviceSubgroupProperties : public layout::PhysicalDeviceSubgroupProperties
   {
     operator VkPhysicalDeviceSubgroupProperties const&() const
     {
@@ -41686,28 +50007,214 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t subgroupSize;
-    ShaderStageFlags supportedStages;
-    SubgroupFeatureFlags supportedOperations;
-    Bool32 quadOperationsInAllStages;
+    using layout::PhysicalDeviceSubgroupProperties::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceSubgroupSizeControlFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0,
+                                                    vk::Bool32 computeFullSubgroups_ = 0 )
+        : subgroupSizeControl( subgroupSizeControl_ )
+        , computeFullSubgroups( computeFullSubgroups_ )
+      {}
+
+      PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 subgroupSizeControl;
+      vk::Bool32 computeFullSubgroups;
+    };
+    static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceSurfaceInfo2KHR
+  struct PhysicalDeviceSubgroupSizeControlFeaturesEXT : public layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT
   {
-    PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() )
-      : surface( surface_ )
+    PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0,
+                                                  vk::Bool32 computeFullSubgroups_ = 0 )
+      : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( subgroupSizeControl_, computeFullSubgroups_ )
     {}
 
-    PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
+    PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs )
+      : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( rhs )
+    {}
+
+    PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs )
     {
-      *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this) = rhs;
+      *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(this) = rhs;
+      return *this;
+    }
+
+    PhysicalDeviceSubgroupSizeControlFeaturesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceSubgroupSizeControlFeaturesEXT & setSubgroupSizeControl( vk::Bool32 subgroupSizeControl_ )
+    {
+      subgroupSizeControl = subgroupSizeControl_;
+      return *this;
+    }
+
+    PhysicalDeviceSubgroupSizeControlFeaturesEXT & setComputeFullSubgroups( vk::Bool32 computeFullSubgroups_ )
+    {
+      computeFullSubgroups = computeFullSubgroups_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( subgroupSizeControl == rhs.subgroupSizeControl )
+          && ( computeFullSubgroups == rhs.computeFullSubgroups );
+    }
+
+    bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
     }
 
+  private:
+    using layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceSubgroupSizeControlPropertiesEXT( uint32_t minSubgroupSize_ = 0,
+                                                      uint32_t maxSubgroupSize_ = 0,
+                                                      uint32_t maxComputeWorkgroupSubgroups_ = 0,
+                                                      vk::ShaderStageFlags requiredSubgroupSizeStages_ = vk::ShaderStageFlags() )
+        : minSubgroupSize( minSubgroupSize_ )
+        , maxSubgroupSize( maxSubgroupSize_ )
+        , maxComputeWorkgroupSubgroups( maxComputeWorkgroupSubgroups_ )
+        , requiredSubgroupSizeStages( requiredSubgroupSizeStages_ )
+      {}
+
+      PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t minSubgroupSize;
+      uint32_t maxSubgroupSize;
+      uint32_t maxComputeWorkgroupSubgroups;
+      vk::ShaderStageFlags requiredSubgroupSizeStages;
+    };
+    static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceSubgroupSizeControlPropertiesEXT : public layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT
+  {
+    operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceSubgroupSizeControlPropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( minSubgroupSize == rhs.minSubgroupSize )
+          && ( maxSubgroupSize == rhs.maxSubgroupSize )
+          && ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups )
+          && ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages );
+    }
+
+    bool operator!=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceSurfaceInfo2KHR
+    {
+    protected:
+      PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() )
+        : surface( surface_ )
+      {}
+
+      PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this) = rhs;
+      }
+
+      PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
+      const void* pNext = nullptr;
+      vk::SurfaceKHR surface;
+    };
+    static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceSurfaceInfo2KHR : public layout::PhysicalDeviceSurfaceInfo2KHR
+  {
+    PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() )
+      : layout::PhysicalDeviceSurfaceInfo2KHR( surface_ )
+    {}
+
+    PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
+      : layout::PhysicalDeviceSurfaceInfo2KHR( rhs )
+    {}
+
     PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
     {
       *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this) = rhs;
@@ -41720,7 +50227,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceSurfaceInfo2KHR & setSurface( SurfaceKHR surface_ )
+    PhysicalDeviceSurfaceInfo2KHR & setSurface( vk::SurfaceKHR surface_ )
     {
       surface = surface_;
       return *this;
@@ -41749,24 +50256,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    SurfaceKHR surface;
+    using layout::PhysicalDeviceSurfaceInfo2KHR::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 )
+        : texelBufferAlignment( texelBufferAlignment_ )
+      {}
+
+      PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
+      PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 texelBufferAlignment;
+    };
+    static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT : public layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT
   {
-    PhysicalDeviceTexelBufferAlignmentFeaturesEXT( Bool32 texelBufferAlignment_ = 0 )
-      : texelBufferAlignment( texelBufferAlignment_ )
+    PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 )
+      : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( texelBufferAlignment_ )
     {}
 
     PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs )
     {
@@ -41780,7 +50311,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setTexelBufferAlignment( Bool32 texelBufferAlignment_ )
+    PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setTexelBufferAlignment( vk::Bool32 texelBufferAlignment_ )
     {
       texelBufferAlignment = texelBufferAlignment_;
       return *this;
@@ -41809,15 +50340,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 texelBufferAlignment;
+    using layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceTexelBufferAlignmentPropertiesEXT( vk::DeviceSize storageTexelBufferOffsetAlignmentBytes_ = 0,
+                                                       vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = 0,
+                                                       vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = 0,
+                                                       vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment_ = 0 )
+        : storageTexelBufferOffsetAlignmentBytes( storageTexelBufferOffsetAlignmentBytes_ )
+        , storageTexelBufferOffsetSingleTexelAlignment( storageTexelBufferOffsetSingleTexelAlignment_ )
+        , uniformTexelBufferOffsetAlignmentBytes( uniformTexelBufferOffsetAlignmentBytes_ )
+        , uniformTexelBufferOffsetSingleTexelAlignment( uniformTexelBufferOffsetSingleTexelAlignment_ )
+      {}
 
-  struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
+      PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+      void* pNext = nullptr;
+      vk::DeviceSize storageTexelBufferOffsetAlignmentBytes;
+      vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment;
+      vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes;
+      vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment;
+    };
+    static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT : public layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT
   {
     operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const&() const
     {
@@ -41845,30 +50410,137 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    DeviceSize storageTexelBufferOffsetAlignmentBytes;
-    Bool32 storageTexelBufferOffsetSingleTexelAlignment;
-    DeviceSize uniformTexelBufferOffsetAlignmentBytes;
-    Bool32 uniformTexelBufferOffsetSingleTexelAlignment;
+    using layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 )
+        : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ )
+      {}
 
-  struct PhysicalDeviceTransformFeedbackFeaturesEXT
+      PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT;
+      const void* pNext = nullptr;
+      vk::Bool32 textureCompressionASTC_HDR;
+    };
+    static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT : public layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
   {
-    PhysicalDeviceTransformFeedbackFeaturesEXT( Bool32 transformFeedback_ = 0,
-                                                Bool32 geometryStreams_ = 0 )
-      : transformFeedback( transformFeedback_ )
-      , geometryStreams( geometryStreams_ )
+    PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 )
+      : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( textureCompressionASTC_HDR_ )
     {}
 
-    PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
+    PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs )
+      : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( rhs )
+    {}
+
+    PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs )
     {
-      *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this) = rhs;
+      *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(this) = rhs;
+      return *this;
+    }
+
+    PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setTextureCompressionASTC_HDR( vk::Bool32 textureCompressionASTC_HDR_ )
+    {
+      textureCompressionASTC_HDR = textureCompressionASTC_HDR_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR );
     }
 
+    bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceTransformFeedbackFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0,
+                                                  vk::Bool32 geometryStreams_ = 0 )
+        : transformFeedback( transformFeedback_ )
+        , geometryStreams( geometryStreams_ )
+      {}
+
+      PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 transformFeedback;
+      vk::Bool32 geometryStreams;
+    };
+    static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceTransformFeedbackFeaturesEXT : public layout::PhysicalDeviceTransformFeedbackFeaturesEXT
+  {
+    PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0,
+                                                vk::Bool32 geometryStreams_ = 0 )
+      : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( transformFeedback_, geometryStreams_ )
+    {}
+
+    PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
+      : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( rhs )
+    {}
+
     PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
     {
       *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this) = rhs;
@@ -41881,13 +50553,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback( Bool32 transformFeedback_ )
+    PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback( vk::Bool32 transformFeedback_ )
     {
       transformFeedback = transformFeedback_;
       return *this;
     }
 
-    PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams( Bool32 geometryStreams_ )
+    PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams( vk::Bool32 geometryStreams_ )
     {
       geometryStreams = geometryStreams_;
       return *this;
@@ -41917,16 +50589,67 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 transformFeedback;
-    Bool32 geometryStreams;
+    using layout::PhysicalDeviceTransformFeedbackFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceTransformFeedbackPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceTransformFeedbackPropertiesEXT( uint32_t maxTransformFeedbackStreams_ = 0,
+                                                    uint32_t maxTransformFeedbackBuffers_ = 0,
+                                                    vk::DeviceSize maxTransformFeedbackBufferSize_ = 0,
+                                                    uint32_t maxTransformFeedbackStreamDataSize_ = 0,
+                                                    uint32_t maxTransformFeedbackBufferDataSize_ = 0,
+                                                    uint32_t maxTransformFeedbackBufferDataStride_ = 0,
+                                                    vk::Bool32 transformFeedbackQueries_ = 0,
+                                                    vk::Bool32 transformFeedbackStreamsLinesTriangles_ = 0,
+                                                    vk::Bool32 transformFeedbackRasterizationStreamSelect_ = 0,
+                                                    vk::Bool32 transformFeedbackDraw_ = 0 )
+        : maxTransformFeedbackStreams( maxTransformFeedbackStreams_ )
+        , maxTransformFeedbackBuffers( maxTransformFeedbackBuffers_ )
+        , maxTransformFeedbackBufferSize( maxTransformFeedbackBufferSize_ )
+        , maxTransformFeedbackStreamDataSize( maxTransformFeedbackStreamDataSize_ )
+        , maxTransformFeedbackBufferDataSize( maxTransformFeedbackBufferDataSize_ )
+        , maxTransformFeedbackBufferDataStride( maxTransformFeedbackBufferDataStride_ )
+        , transformFeedbackQueries( transformFeedbackQueries_ )
+        , transformFeedbackStreamsLinesTriangles( transformFeedbackStreamsLinesTriangles_ )
+        , transformFeedbackRasterizationStreamSelect( transformFeedbackRasterizationStreamSelect_ )
+        , transformFeedbackDraw( transformFeedbackDraw_ )
+      {}
+
+      PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceTransformFeedbackPropertiesEXT
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t maxTransformFeedbackStreams;
+      uint32_t maxTransformFeedbackBuffers;
+      vk::DeviceSize maxTransformFeedbackBufferSize;
+      uint32_t maxTransformFeedbackStreamDataSize;
+      uint32_t maxTransformFeedbackBufferDataSize;
+      uint32_t maxTransformFeedbackBufferDataStride;
+      vk::Bool32 transformFeedbackQueries;
+      vk::Bool32 transformFeedbackStreamsLinesTriangles;
+      vk::Bool32 transformFeedbackRasterizationStreamSelect;
+      vk::Bool32 transformFeedbackDraw;
+    };
+    static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceTransformFeedbackPropertiesEXT : public layout::PhysicalDeviceTransformFeedbackPropertiesEXT
   {
     operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const&() const
     {
@@ -41960,33 +50683,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxTransformFeedbackStreams;
-    uint32_t maxTransformFeedbackBuffers;
-    DeviceSize maxTransformFeedbackBufferSize;
-    uint32_t maxTransformFeedbackStreamDataSize;
-    uint32_t maxTransformFeedbackBufferDataSize;
-    uint32_t maxTransformFeedbackBufferDataStride;
-    Bool32 transformFeedbackQueries;
-    Bool32 transformFeedbackStreamsLinesTriangles;
-    Bool32 transformFeedbackRasterizationStreamSelect;
-    Bool32 transformFeedbackDraw;
+    using layout::PhysicalDeviceTransformFeedbackPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
+    {
+    protected:
+      PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 )
+        : uniformBufferStandardLayout( uniformBufferStandardLayout_ )
+      {}
+
+      PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(this) = rhs;
+      }
+
+      PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
+      void* pNext = nullptr;
+      vk::Bool32 uniformBufferStandardLayout;
+    };
+    static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR : public layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
   {
-    PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( Bool32 uniformBufferStandardLayout_ = 0 )
-      : uniformBufferStandardLayout( uniformBufferStandardLayout_ )
+    PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 )
+      : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( uniformBufferStandardLayout_ )
     {}
 
     PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( rhs )
+    {}
 
     PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs )
     {
@@ -42000,7 +50738,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ )
+    PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & setUniformBufferStandardLayout( vk::Bool32 uniformBufferStandardLayout_ )
     {
       uniformBufferStandardLayout = uniformBufferStandardLayout_;
       return *this;
@@ -42029,26 +50767,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 uniformBufferStandardLayout;
+    using layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::sType;
   };
   static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceVariablePointersFeatures
+    {
+    protected:
+      PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0,
+                                              vk::Bool32 variablePointers_ = 0 )
+        : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
+        , variablePointers( variablePointers_ )
+      {}
+
+      PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(this) = rhs;
+      }
+
+      PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures;
+      void* pNext = nullptr;
+      vk::Bool32 variablePointersStorageBuffer;
+      vk::Bool32 variablePointers;
+    };
+    static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PhysicalDeviceVariablePointersFeatures
+  struct PhysicalDeviceVariablePointersFeatures : public layout::PhysicalDeviceVariablePointersFeatures
   {
-    PhysicalDeviceVariablePointersFeatures( Bool32 variablePointersStorageBuffer_ = 0,
-                                            Bool32 variablePointers_ = 0 )
-      : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
-      , variablePointers( variablePointers_ )
+    PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0,
+                                            vk::Bool32 variablePointers_ = 0 )
+      : layout::PhysicalDeviceVariablePointersFeatures( variablePointersStorageBuffer_, variablePointers_ )
     {}
 
     PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceVariablePointersFeatures( rhs )
+    {}
 
     PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs )
     {
@@ -42062,13 +50826,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceVariablePointersFeatures & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ )
+    PhysicalDeviceVariablePointersFeatures & setVariablePointersStorageBuffer( vk::Bool32 variablePointersStorageBuffer_ )
     {
       variablePointersStorageBuffer = variablePointersStorageBuffer_;
       return *this;
     }
 
-    PhysicalDeviceVariablePointersFeatures & setVariablePointers( Bool32 variablePointers_ )
+    PhysicalDeviceVariablePointersFeatures & setVariablePointers( vk::Bool32 variablePointers_ )
     {
       variablePointers = variablePointers_;
       return *this;
@@ -42098,27 +50862,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 variablePointersStorageBuffer;
-    Bool32 variablePointers;
+    using layout::PhysicalDeviceVariablePointersFeatures::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0,
+                                                       vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
+        : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
+        , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
+      {}
+
+      PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this) = rhs;
+      }
+
+      PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 vertexAttributeInstanceRateDivisor;
+      vk::Bool32 vertexAttributeInstanceRateZeroDivisor;
+    };
+    static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT : public layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT
   {
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT( Bool32 vertexAttributeInstanceRateDivisor_ = 0,
-                                                     Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
-      : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
-      , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0,
+                                                     vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
+      : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vertexAttributeInstanceRateDivisor_, vertexAttributeInstanceRateZeroDivisor_ )
     {}
 
     PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
     {
@@ -42132,13 +50921,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ )
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateDivisor( vk::Bool32 vertexAttributeInstanceRateDivisor_ )
     {
       vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_;
       return *this;
     }
 
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ )
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateZeroDivisor( vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ )
     {
       vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_;
       return *this;
@@ -42168,16 +50957,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 vertexAttributeInstanceRateDivisor;
-    Bool32 vertexAttributeInstanceRateZeroDivisor;
+    using layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
+    {
+    protected:
+      PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = 0 )
+        : maxVertexAttribDivisor( maxVertexAttribDivisor_ )
+      {}
+
+      PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
+      PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+      void* pNext = nullptr;
+      uint32_t maxVertexAttribDivisor;
+    };
+    static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT : public layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT
   {
     operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const
     {
@@ -42202,28 +51015,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxVertexAttribDivisor;
+    using layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
+    {
+    protected:
+      PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0,
+                                                  vk::Bool32 vulkanMemoryModelDeviceScope_ = 0,
+                                                  vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 )
+        : vulkanMemoryModel( vulkanMemoryModel_ )
+        , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ )
+        , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ )
+      {}
+
+      PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
+      PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR;
+      void* pNext = nullptr;
+      vk::Bool32 vulkanMemoryModel;
+      vk::Bool32 vulkanMemoryModelDeviceScope;
+      vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains;
+    };
+    static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceVulkanMemoryModelFeaturesKHR : public layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR
   {
-    PhysicalDeviceVulkanMemoryModelFeaturesKHR( Bool32 vulkanMemoryModel_ = 0,
-                                                Bool32 vulkanMemoryModelDeviceScope_ = 0,
-                                                Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 )
-      : vulkanMemoryModel( vulkanMemoryModel_ )
-      , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ )
-      , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ )
+    PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0,
+                                                vk::Bool32 vulkanMemoryModelDeviceScope_ = 0,
+                                                vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 )
+      : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( vulkanMemoryModel_, vulkanMemoryModelDeviceScope_, vulkanMemoryModelAvailabilityVisibilityChains_ )
     {}
 
     PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( rhs )
+    {}
 
     PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs )
     {
@@ -42237,19 +51078,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModel( Bool32 vulkanMemoryModel_ )
+    PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModel( vk::Bool32 vulkanMemoryModel_ )
     {
       vulkanMemoryModel = vulkanMemoryModel_;
       return *this;
     }
 
-    PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ )
+    PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelDeviceScope( vk::Bool32 vulkanMemoryModelDeviceScope_ )
     {
       vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_;
       return *this;
     }
 
-    PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ )
+    PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelAvailabilityVisibilityChains( vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ )
     {
       vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_;
       return *this;
@@ -42280,26 +51121,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 vulkanMemoryModel;
-    Bool32 vulkanMemoryModelDeviceScope;
-    Bool32 vulkanMemoryModelAvailabilityVisibilityChains;
+    using layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::sType;
   };
   static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceVulkanMemoryModelFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
+    {
+    protected:
+      PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 )
+        : ycbcrImageArrays( ycbcrImageArrays_ )
+      {}
+
+      PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this) = rhs;
+      }
 
-  struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
+      PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT;
+      void* pNext = nullptr;
+      vk::Bool32 ycbcrImageArrays;
+    };
+    static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PhysicalDeviceYcbcrImageArraysFeaturesEXT : public layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT
   {
-    PhysicalDeviceYcbcrImageArraysFeaturesEXT( Bool32 ycbcrImageArrays_ = 0 )
-      : ycbcrImageArrays( ycbcrImageArrays_ )
+    PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 )
+      : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( ycbcrImageArrays_ )
     {}
 
     PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this) = rhs;
-    }
+      : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( rhs )
+    {}
 
     PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs )
     {
@@ -42313,7 +51176,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PhysicalDeviceYcbcrImageArraysFeaturesEXT & setYcbcrImageArrays( Bool32 ycbcrImageArrays_ )
+    PhysicalDeviceYcbcrImageArraysFeaturesEXT & setYcbcrImageArrays( vk::Bool32 ycbcrImageArrays_ )
     {
       ycbcrImageArrays = ycbcrImageArrays_;
       return *this;
@@ -42342,28 +51205,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 ycbcrImageArrays;
+    using layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::sType;
   };
   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!" );
 
-  struct PipelineCacheCreateInfo
+  namespace layout
   {
-    PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(),
+    struct PipelineCacheCreateInfo
+    {
+    protected:
+      PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(),
+                               size_t initialDataSize_ = 0,
+                               const void* pInitialData_ = nullptr )
+        : flags( flags_ )
+        , initialDataSize( initialDataSize_ )
+        , pInitialData( pInitialData_ )
+      {}
+
+      PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCacheCreateInfo*>(this) = rhs;
+      }
+
+      PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCacheCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineCacheCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineCacheCreateFlags flags;
+      size_t initialDataSize;
+      const void* pInitialData;
+    };
+    static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineCacheCreateInfo : public layout::PipelineCacheCreateInfo
+  {
+    PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(),
                              size_t initialDataSize_ = 0,
                              const void* pInitialData_ = nullptr )
-      : flags( flags_ )
-      , initialDataSize( initialDataSize_ )
-      , pInitialData( pInitialData_ )
+      : layout::PipelineCacheCreateInfo( flags_, initialDataSize_, pInitialData_ )
     {}
 
     PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineCacheCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineCacheCreateInfo( rhs )
+    {}
 
     PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
     {
@@ -42377,7 +51268,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineCacheCreateInfo & setFlags( PipelineCacheCreateFlags flags_ )
+    PipelineCacheCreateInfo & setFlags( vk::PipelineCacheCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -42420,30 +51311,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineCacheCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCacheCreateFlags flags;
-    size_t initialDataSize;
-    const void* pInitialData;
+    using layout::PipelineCacheCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineColorBlendAdvancedStateCreateInfoEXT
+    {
+    protected:
+      PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0,
+                                                    vk::Bool32 dstPremultiplied_ = 0,
+                                                    vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated )
+        : srcPremultiplied( srcPremultiplied_ )
+        , dstPremultiplied( dstPremultiplied_ )
+        , blendOverlap( blendOverlap_ )
+      {}
+
+      PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::Bool32 srcPremultiplied;
+      vk::Bool32 dstPremultiplied;
+      vk::BlendOverlapEXT blendOverlap;
+    };
+    static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineColorBlendAdvancedStateCreateInfoEXT
+  struct PipelineColorBlendAdvancedStateCreateInfoEXT : public layout::PipelineColorBlendAdvancedStateCreateInfoEXT
   {
-    PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0,
-                                                  Bool32 dstPremultiplied_ = 0,
-                                                  BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
-      : srcPremultiplied( srcPremultiplied_ )
-      , dstPremultiplied( dstPremultiplied_ )
-      , blendOverlap( blendOverlap_ )
+    PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0,
+                                                  vk::Bool32 dstPremultiplied_ = 0,
+                                                  vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated )
+      : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( srcPremultiplied_, dstPremultiplied_, blendOverlap_ )
     {}
 
     PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( rhs )
+    {}
 
     PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
     {
@@ -42457,19 +51374,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineColorBlendAdvancedStateCreateInfoEXT & setSrcPremultiplied( Bool32 srcPremultiplied_ )
+    PipelineColorBlendAdvancedStateCreateInfoEXT & setSrcPremultiplied( vk::Bool32 srcPremultiplied_ )
     {
       srcPremultiplied = srcPremultiplied_;
       return *this;
     }
 
-    PipelineColorBlendAdvancedStateCreateInfoEXT & setDstPremultiplied( Bool32 dstPremultiplied_ )
+    PipelineColorBlendAdvancedStateCreateInfoEXT & setDstPremultiplied( vk::Bool32 dstPremultiplied_ )
     {
       dstPremultiplied = dstPremultiplied_;
       return *this;
     }
 
-    PipelineColorBlendAdvancedStateCreateInfoEXT & setBlendOverlap( BlendOverlapEXT blendOverlap_ )
+    PipelineColorBlendAdvancedStateCreateInfoEXT & setBlendOverlap( vk::BlendOverlapEXT blendOverlap_ )
     {
       blendOverlap = blendOverlap_;
       return *this;
@@ -42500,34 +51417,148 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 srcPremultiplied;
-    Bool32 dstPremultiplied;
-    BlendOverlapEXT blendOverlap;
+    using layout::PipelineColorBlendAdvancedStateCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineCompilerControlCreateInfoAMD
+    {
+    protected:
+      PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() )
+        : compilerControlFlags( compilerControlFlags_ )
+      {}
+
+      PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(this) = rhs;
+      }
+
+      PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD;
+      const void* pNext = nullptr;
+      vk::PipelineCompilerControlFlagsAMD compilerControlFlags;
+    };
+    static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineCompilerControlCreateInfoAMD : public layout::PipelineCompilerControlCreateInfoAMD
+  {
+    PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() )
+      : layout::PipelineCompilerControlCreateInfoAMD( compilerControlFlags_ )
+    {}
+
+    PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs )
+      : layout::PipelineCompilerControlCreateInfoAMD( rhs )
+    {}
+
+    PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs )
+    {
+      *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(this) = rhs;
+      return *this;
+    }
+
+    PipelineCompilerControlCreateInfoAMD & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineCompilerControlCreateInfoAMD & setCompilerControlFlags( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ )
+    {
+      compilerControlFlags = compilerControlFlags_;
+      return *this;
+    }
+
+    operator VkPipelineCompilerControlCreateInfoAMD const&() const
+    {
+      return *reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>( this );
+    }
+
+    operator VkPipelineCompilerControlCreateInfoAMD &()
+    {
+      return *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>( this );
+    }
+
+    bool operator==( PipelineCompilerControlCreateInfoAMD const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( compilerControlFlags == rhs.compilerControlFlags );
+    }
+
+    bool operator!=( PipelineCompilerControlCreateInfoAMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PipelineCompilerControlCreateInfoAMD::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PipelineCoverageModulationStateCreateInfoNV
+    {
+    protected:
+      PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(),
+                                                   vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone,
+                                                   vk::Bool32 coverageModulationTableEnable_ = 0,
+                                                   uint32_t coverageModulationTableCount_ = 0,
+                                                   const float* pCoverageModulationTable_ = nullptr )
+        : flags( flags_ )
+        , coverageModulationMode( coverageModulationMode_ )
+        , coverageModulationTableEnable( coverageModulationTableEnable_ )
+        , coverageModulationTableCount( coverageModulationTableCount_ )
+        , pCoverageModulationTable( pCoverageModulationTable_ )
+      {}
+
+      PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this) = rhs;
+      }
 
-  struct PipelineCoverageModulationStateCreateInfoNV
+      PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::PipelineCoverageModulationStateCreateFlagsNV flags;
+      vk::CoverageModulationModeNV coverageModulationMode;
+      vk::Bool32 coverageModulationTableEnable;
+      uint32_t coverageModulationTableCount;
+      const float* pCoverageModulationTable;
+    };
+    static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineCoverageModulationStateCreateInfoNV : public layout::PipelineCoverageModulationStateCreateInfoNV
   {
-    PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(),
-                                                 CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone,
-                                                 Bool32 coverageModulationTableEnable_ = 0,
+    PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(),
+                                                 vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone,
+                                                 vk::Bool32 coverageModulationTableEnable_ = 0,
                                                  uint32_t coverageModulationTableCount_ = 0,
                                                  const float* pCoverageModulationTable_ = nullptr )
-      : flags( flags_ )
-      , coverageModulationMode( coverageModulationMode_ )
-      , coverageModulationTableEnable( coverageModulationTableEnable_ )
-      , coverageModulationTableCount( coverageModulationTableCount_ )
-      , pCoverageModulationTable( pCoverageModulationTable_ )
+      : layout::PipelineCoverageModulationStateCreateInfoNV( flags_, coverageModulationMode_, coverageModulationTableEnable_, coverageModulationTableCount_, pCoverageModulationTable_ )
     {}
 
     PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineCoverageModulationStateCreateInfoNV( rhs )
+    {}
 
     PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
     {
@@ -42541,19 +51572,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineCoverageModulationStateCreateInfoNV & setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ )
+    PipelineCoverageModulationStateCreateInfoNV & setFlags( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ )
+    PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationMode( vk::CoverageModulationModeNV coverageModulationMode_ )
     {
       coverageModulationMode = coverageModulationMode_;
       return *this;
     }
 
-    PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ )
+    PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableEnable( vk::Bool32 coverageModulationTableEnable_ )
     {
       coverageModulationTableEnable = coverageModulationTableEnable_;
       return *this;
@@ -42598,30 +51629,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCoverageModulationStateCreateFlagsNV flags;
-    CoverageModulationModeNV coverageModulationMode;
-    Bool32 coverageModulationTableEnable;
-    uint32_t coverageModulationTableCount;
-    const float* pCoverageModulationTable;
+    using layout::PipelineCoverageModulationStateCreateInfoNV::sType;
   };
   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!" );
 
-  struct PipelineCoverageReductionStateCreateInfoNV
+  namespace layout
   {
-    PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateFlagsNV flags_ = PipelineCoverageReductionStateCreateFlagsNV(),
-                                                CoverageReductionModeNV coverageReductionMode_ = CoverageReductionModeNV::eMerge )
-      : flags( flags_ )
-      , coverageReductionMode( coverageReductionMode_ )
+    struct PipelineCoverageReductionStateCreateInfoNV
+    {
+    protected:
+      PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(),
+                                                  vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge )
+        : flags( flags_ )
+        , coverageReductionMode( coverageReductionMode_ )
+      {}
+
+      PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(this) = rhs;
+      }
+
+      PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::PipelineCoverageReductionStateCreateFlagsNV flags;
+      vk::CoverageReductionModeNV coverageReductionMode;
+    };
+    static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineCoverageReductionStateCreateInfoNV : public layout::PipelineCoverageReductionStateCreateInfoNV
+  {
+    PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(),
+                                                vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge )
+      : layout::PipelineCoverageReductionStateCreateInfoNV( flags_, coverageReductionMode_ )
     {}
 
     PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineCoverageReductionStateCreateInfoNV( rhs )
+    {}
 
     PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs )
     {
@@ -42635,13 +51688,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineCoverageReductionStateCreateInfoNV & setFlags( PipelineCoverageReductionStateCreateFlagsNV flags_ )
+    PipelineCoverageReductionStateCreateInfoNV & setFlags( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineCoverageReductionStateCreateInfoNV & setCoverageReductionMode( CoverageReductionModeNV coverageReductionMode_ )
+    PipelineCoverageReductionStateCreateInfoNV & setCoverageReductionMode( vk::CoverageReductionModeNV coverageReductionMode_ )
     {
       coverageReductionMode = coverageReductionMode_;
       return *this;
@@ -42671,29 +51724,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCoverageReductionStateCreateFlagsNV flags;
-    CoverageReductionModeNV coverageReductionMode;
+    using layout::PipelineCoverageReductionStateCreateInfoNV::sType;
   };
   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!" );
 
-  struct PipelineCoverageToColorStateCreateInfoNV
+  namespace layout
   {
-    PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(),
-                                              Bool32 coverageToColorEnable_ = 0,
+    struct PipelineCoverageToColorStateCreateInfoNV
+    {
+    protected:
+      PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(),
+                                                vk::Bool32 coverageToColorEnable_ = 0,
+                                                uint32_t coverageToColorLocation_ = 0 )
+        : flags( flags_ )
+        , coverageToColorEnable( coverageToColorEnable_ )
+        , coverageToColorLocation( coverageToColorLocation_ )
+      {}
+
+      PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this) = rhs;
+      }
+
+      PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::PipelineCoverageToColorStateCreateFlagsNV flags;
+      vk::Bool32 coverageToColorEnable;
+      uint32_t coverageToColorLocation;
+    };
+    static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineCoverageToColorStateCreateInfoNV : public layout::PipelineCoverageToColorStateCreateInfoNV
+  {
+    PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(),
+                                              vk::Bool32 coverageToColorEnable_ = 0,
                                               uint32_t coverageToColorLocation_ = 0 )
-      : flags( flags_ )
-      , coverageToColorEnable( coverageToColorEnable_ )
-      , coverageToColorLocation( coverageToColorLocation_ )
+      : layout::PipelineCoverageToColorStateCreateInfoNV( flags_, coverageToColorEnable_, coverageToColorLocation_ )
     {}
 
     PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineCoverageToColorStateCreateInfoNV( rhs )
+    {}
 
     PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
     {
@@ -42707,13 +51787,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineCoverageToColorStateCreateInfoNV & setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ )
+    PipelineCoverageToColorStateCreateInfoNV & setFlags( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorEnable( Bool32 coverageToColorEnable_ )
+    PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorEnable( vk::Bool32 coverageToColorEnable_ )
     {
       coverageToColorEnable = coverageToColorEnable_;
       return *this;
@@ -42750,15 +51830,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCoverageToColorStateCreateFlagsNV flags;
-    Bool32 coverageToColorEnable;
-    uint32_t coverageToColorLocation;
+    using layout::PipelineCoverageToColorStateCreateInfoNV::sType;
   };
   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!" );
 
   struct PipelineCreationFeedbackEXT
   {
@@ -42783,25 +51858,58 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    PipelineCreationFeedbackFlagsEXT flags;
+  public:
+    vk::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
+  namespace layout
   {
-    PipelineCreationFeedbackCreateInfoEXT( PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr,
+    struct PipelineCreationFeedbackCreateInfoEXT
+    {
+    protected:
+      PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr,
+                                             uint32_t pipelineStageCreationFeedbackCount_ = 0,
+                                             vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr )
+        : pPipelineCreationFeedback( pPipelineCreationFeedback_ )
+        , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ )
+        , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ )
+      {}
+
+      PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback;
+      uint32_t pipelineStageCreationFeedbackCount;
+      vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks;
+    };
+    static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineCreationFeedbackCreateInfoEXT : public layout::PipelineCreationFeedbackCreateInfoEXT
+  {
+    PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr,
                                            uint32_t pipelineStageCreationFeedbackCount_ = 0,
-                                           PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr )
-      : pPipelineCreationFeedback( pPipelineCreationFeedback_ )
-      , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ )
-      , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ )
+                                           vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr )
+      : layout::PipelineCreationFeedbackCreateInfoEXT( pPipelineCreationFeedback_, pipelineStageCreationFeedbackCount_, pPipelineStageCreationFeedbacks_ )
     {}
 
     PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::PipelineCreationFeedbackCreateInfoEXT( rhs )
+    {}
 
     PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs )
     {
@@ -42815,7 +51923,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineCreationFeedbackCreateInfoEXT & setPPipelineCreationFeedback( PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ )
+    PipelineCreationFeedbackCreateInfoEXT & setPPipelineCreationFeedback( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ )
     {
       pPipelineCreationFeedback = pPipelineCreationFeedback_;
       return *this;
@@ -42827,7 +51935,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineCreationFeedbackCreateInfoEXT & setPPipelineStageCreationFeedbacks( PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ )
+    PipelineCreationFeedbackCreateInfoEXT & setPPipelineStageCreationFeedbacks( vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ )
     {
       pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks_;
       return *this;
@@ -42858,32 +51966,60 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCreationFeedbackEXT* pPipelineCreationFeedback;
-    uint32_t pipelineStageCreationFeedbackCount;
-    PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks;
+    using layout::PipelineCreationFeedbackCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineDiscardRectangleStateCreateInfoEXT
+    {
+    protected:
+      PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(),
+                                                  vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive,
+                                                  uint32_t discardRectangleCount_ = 0,
+                                                  const vk::Rect2D* pDiscardRectangles_ = nullptr )
+        : flags( flags_ )
+        , discardRectangleMode( discardRectangleMode_ )
+        , discardRectangleCount( discardRectangleCount_ )
+        , pDiscardRectangles( pDiscardRectangles_ )
+      {}
+
+      PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
 
-  struct PipelineDiscardRectangleStateCreateInfoEXT
+    public:
+      vk::StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::PipelineDiscardRectangleStateCreateFlagsEXT flags;
+      vk::DiscardRectangleModeEXT discardRectangleMode;
+      uint32_t discardRectangleCount;
+      const vk::Rect2D* pDiscardRectangles;
+    };
+    static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineDiscardRectangleStateCreateInfoEXT : public layout::PipelineDiscardRectangleStateCreateInfoEXT
   {
-    PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(),
-                                                DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive,
+    PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(),
+                                                vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive,
                                                 uint32_t discardRectangleCount_ = 0,
-                                                const Rect2D* pDiscardRectangles_ = nullptr )
-      : flags( flags_ )
-      , discardRectangleMode( discardRectangleMode_ )
-      , discardRectangleCount( discardRectangleCount_ )
-      , pDiscardRectangles( pDiscardRectangles_ )
+                                                const vk::Rect2D* pDiscardRectangles_ = nullptr )
+      : layout::PipelineDiscardRectangleStateCreateInfoEXT( flags_, discardRectangleMode_, discardRectangleCount_, pDiscardRectangles_ )
     {}
 
     PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::PipelineDiscardRectangleStateCreateInfoEXT( rhs )
+    {}
 
     PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
     {
@@ -42897,13 +52033,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineDiscardRectangleStateCreateInfoEXT & setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
+    PipelineDiscardRectangleStateCreateInfoEXT & setFlags( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ )
+    PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleMode( vk::DiscardRectangleModeEXT discardRectangleMode_ )
     {
       discardRectangleMode = discardRectangleMode_;
       return *this;
@@ -42915,7 +52051,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineDiscardRectangleStateCreateInfoEXT & setPDiscardRectangles( const Rect2D* pDiscardRectangles_ )
+    PipelineDiscardRectangleStateCreateInfoEXT & setPDiscardRectangles( const vk::Rect2D* pDiscardRectangles_ )
     {
       pDiscardRectangles = pDiscardRectangles_;
       return *this;
@@ -42947,25 +52083,482 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineDiscardRectangleStateCreateFlagsEXT flags;
-    DiscardRectangleModeEXT discardRectangleMode;
-    uint32_t discardRectangleCount;
-    const Rect2D* pDiscardRectangles;
+    using layout::PipelineDiscardRectangleStateCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineExecutableInfoKHR
+    {
+    protected:
+      PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(),
+                                 uint32_t executableIndex_ = 0 )
+        : pipeline( pipeline_ )
+        , executableIndex( executableIndex_ )
+      {}
+
+      PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineExecutableInfoKHR*>(this) = rhs;
+      }
+
+      PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineExecutableInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineExecutableInfoKHR;
+      const void* pNext = nullptr;
+      vk::Pipeline pipeline;
+      uint32_t executableIndex;
+    };
+    static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineExecutableInfoKHR : public layout::PipelineExecutableInfoKHR
+  {
+    PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(),
+                               uint32_t executableIndex_ = 0 )
+      : layout::PipelineExecutableInfoKHR( pipeline_, executableIndex_ )
+    {}
+
+    PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs )
+      : layout::PipelineExecutableInfoKHR( rhs )
+    {}
+
+    PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs )
+    {
+      *reinterpret_cast<VkPipelineExecutableInfoKHR*>(this) = rhs;
+      return *this;
+    }
+
+    PipelineExecutableInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineExecutableInfoKHR & setPipeline( vk::Pipeline pipeline_ )
+    {
+      pipeline = pipeline_;
+      return *this;
+    }
+
+    PipelineExecutableInfoKHR & setExecutableIndex( uint32_t executableIndex_ )
+    {
+      executableIndex = executableIndex_;
+      return *this;
+    }
+
+    operator VkPipelineExecutableInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkPipelineExecutableInfoKHR*>( this );
+    }
+
+    operator VkPipelineExecutableInfoKHR &()
+    {
+      return *reinterpret_cast<VkPipelineExecutableInfoKHR*>( this );
+    }
+
+    bool operator==( PipelineExecutableInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pipeline == rhs.pipeline )
+          && ( executableIndex == rhs.executableIndex );
+    }
+
+    bool operator!=( PipelineExecutableInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PipelineExecutableInfoKHR::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PipelineExecutableInternalRepresentationKHR
+    {
+    protected:
+      PipelineExecutableInternalRepresentationKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+                                                   std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } },
+                                                   vk::Bool32 isText_ = 0,
+                                                   size_t dataSize_ = 0,
+                                                   void* pData_ = nullptr )
+        : isText( isText_ )
+        , dataSize( dataSize_ )
+        , pData( pData_ )
+      {
+        memcpy( &name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+        memcpy( &description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+      
+      }
+
+      PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this) = rhs;
+      }
+
+      PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR;
+      void* pNext = nullptr;
+      char name[VK_MAX_DESCRIPTION_SIZE];
+      char description[VK_MAX_DESCRIPTION_SIZE];
+      vk::Bool32 isText;
+      size_t dataSize;
+      void* pData;
+    };
+    static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineExecutableInternalRepresentationKHR : public layout::PipelineExecutableInternalRepresentationKHR
+  {
+    PipelineExecutableInternalRepresentationKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+                                                 std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } },
+                                                 vk::Bool32 isText_ = 0,
+                                                 size_t dataSize_ = 0,
+                                                 void* pData_ = nullptr )
+      : layout::PipelineExecutableInternalRepresentationKHR( name_, description_, isText_, dataSize_, pData_ )
+    {}
+
+    PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs )
+      : layout::PipelineExecutableInternalRepresentationKHR( rhs )
+    {}
+
+    PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs )
+    {
+      *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this) = rhs;
+      return *this;
+    }
+
+    PipelineExecutableInternalRepresentationKHR & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineExecutableInternalRepresentationKHR & setName( std::array<char,VK_MAX_DESCRIPTION_SIZE> name_ )
+    {
+      memcpy( name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+      return *this;
+    }
+
+    PipelineExecutableInternalRepresentationKHR & setDescription( std::array<char,VK_MAX_DESCRIPTION_SIZE> description_ )
+    {
+      memcpy( description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+      return *this;
+    }
+
+    PipelineExecutableInternalRepresentationKHR & setIsText( vk::Bool32 isText_ )
+    {
+      isText = isText_;
+      return *this;
+    }
+
+    PipelineExecutableInternalRepresentationKHR & setDataSize( size_t dataSize_ )
+    {
+      dataSize = dataSize_;
+      return *this;
+    }
+
+    PipelineExecutableInternalRepresentationKHR & setPData( void* pData_ )
+    {
+      pData = pData_;
+      return *this;
+    }
+
+    operator VkPipelineExecutableInternalRepresentationKHR const&() const
+    {
+      return *reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR*>( this );
+    }
+
+    operator VkPipelineExecutableInternalRepresentationKHR &()
+    {
+      return *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( this );
+    }
+
+    bool operator==( PipelineExecutableInternalRepresentationKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+          && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+          && ( isText == rhs.isText )
+          && ( dataSize == rhs.dataSize )
+          && ( pData == rhs.pData );
+    }
+
+    bool operator!=( PipelineExecutableInternalRepresentationKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PipelineExecutableInternalRepresentationKHR::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PipelineExecutablePropertiesKHR
+    {
+    protected:
+      PipelineExecutablePropertiesKHR( vk::ShaderStageFlags stages_ = vk::ShaderStageFlags(),
+                                       std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+                                       std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } },
+                                       uint32_t subgroupSize_ = 0 )
+        : stages( stages_ )
+        , subgroupSize( subgroupSize_ )
+      {
+        memcpy( &name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+        memcpy( &description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+      
+      }
+
+      PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(this) = rhs;
+      }
+
+      PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR;
+      void* pNext = nullptr;
+      vk::ShaderStageFlags stages;
+      char name[VK_MAX_DESCRIPTION_SIZE];
+      char description[VK_MAX_DESCRIPTION_SIZE];
+      uint32_t subgroupSize;
+    };
+    static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineExecutablePropertiesKHR : public layout::PipelineExecutablePropertiesKHR
+  {
+    operator VkPipelineExecutablePropertiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkPipelineExecutablePropertiesKHR*>( this );
+    }
+
+    operator VkPipelineExecutablePropertiesKHR &()
+    {
+      return *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( this );
+    }
+
+    bool operator==( PipelineExecutablePropertiesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( stages == rhs.stages )
+          && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+          && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+          && ( subgroupSize == rhs.subgroupSize );
+    }
+
+    bool operator!=( PipelineExecutablePropertiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PipelineExecutablePropertiesKHR::sType;
+  };
+  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!" );
+
+  union PipelineExecutableStatisticValueKHR
+  {
+    operator VkPipelineExecutableStatisticValueKHR const&() const
+    {
+      return *reinterpret_cast<const VkPipelineExecutableStatisticValueKHR*>(this);
+    }
+
+    operator VkPipelineExecutableStatisticValueKHR &()
+    {
+      return *reinterpret_cast<VkPipelineExecutableStatisticValueKHR*>(this);
+    }
+
+#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+    vk::Bool32 b32;
+    int64_t i64;
+    uint64_t u64;
+    double f64;
+#else
+    VkBool32 b32;
+    int64_t i64;
+    uint64_t u64;
+    double f64;
+#endif  /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
+  };
+
+  namespace layout
+  {
+    struct PipelineExecutableStatisticKHR
+    {
+    protected:
+      PipelineExecutableStatisticKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+                                      std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } },
+                                      vk::PipelineExecutableStatisticFormatKHR format_ = vk::PipelineExecutableStatisticFormatKHR::eBool32,
+                                      vk::PipelineExecutableStatisticValueKHR value_ = vk::PipelineExecutableStatisticValueKHR() )
+        : format( format_ )
+        , value( value_ )
+      {
+        memcpy( &name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+        memcpy( &description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+      
+      }
+
+      PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineExecutableStatisticKHR*>(this) = rhs;
+      }
+
+      PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineExecutableStatisticKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineExecutableStatisticKHR;
+      void* pNext = nullptr;
+      char name[VK_MAX_DESCRIPTION_SIZE];
+      char description[VK_MAX_DESCRIPTION_SIZE];
+      vk::PipelineExecutableStatisticFormatKHR format;
+      vk::PipelineExecutableStatisticValueKHR value;
+    };
+    static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineExecutableStatisticKHR : public layout::PipelineExecutableStatisticKHR
+  {
+    operator VkPipelineExecutableStatisticKHR const&() const
+    {
+      return *reinterpret_cast<const VkPipelineExecutableStatisticKHR*>( this );
+    }
+
+    operator VkPipelineExecutableStatisticKHR &()
+    {
+      return *reinterpret_cast<VkPipelineExecutableStatisticKHR*>( this );
+    }
+
+  private:
+    using layout::PipelineExecutableStatisticKHR::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PipelineInfoKHR
+    {
+    protected:
+      PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() )
+        : pipeline( pipeline_ )
+      {}
+
+      PipelineInfoKHR( VkPipelineInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineInfoKHR*>(this) = rhs;
+      }
+
+      PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkPipelineInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineInfoKHR;
+      const void* pNext = nullptr;
+      vk::Pipeline pipeline;
+    };
+    static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineInfoKHR : public layout::PipelineInfoKHR
+  {
+    PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() )
+      : layout::PipelineInfoKHR( pipeline_ )
+    {}
+
+    PipelineInfoKHR( VkPipelineInfoKHR const & rhs )
+      : layout::PipelineInfoKHR( rhs )
+    {}
+
+    PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs )
+    {
+      *reinterpret_cast<VkPipelineInfoKHR*>(this) = rhs;
+      return *this;
+    }
+
+    PipelineInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineInfoKHR & setPipeline( vk::Pipeline pipeline_ )
+    {
+      pipeline = pipeline_;
+      return *this;
+    }
+
+    operator VkPipelineInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkPipelineInfoKHR*>( this );
+    }
+
+    operator VkPipelineInfoKHR &()
+    {
+      return *reinterpret_cast<VkPipelineInfoKHR*>( this );
+    }
+
+    bool operator==( PipelineInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pipeline == rhs.pipeline );
+    }
+
+    bool operator!=( PipelineInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PipelineInfoKHR::sType;
+  };
+  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!" );
 
   struct PushConstantRange
   {
-    PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(),
+    PushConstantRange( vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags(),
                        uint32_t offset_ = 0,
                        uint32_t size_ = 0 )
-      : stageFlags( stageFlags_ )
-      , offset( offset_ )
-      , size( size_ )
+        : stageFlags( stageFlags_ )
+        , offset( offset_ )
+        , size( size_ )
     {}
 
     PushConstantRange( VkPushConstantRange const & rhs )
@@ -42979,7 +52572,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PushConstantRange & setStageFlags( ShaderStageFlags stageFlags_ )
+    PushConstantRange & setStageFlags( vk::ShaderStageFlags stageFlags_ )
     {
       stageFlags = stageFlags_;
       return *this;
@@ -43019,30 +52612,67 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ShaderStageFlags stageFlags;
+  public:
+    vk::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!" );
+
+  namespace layout
+  {
+    struct PipelineLayoutCreateInfo
+    {
+    protected:
+      PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(),
+                                uint32_t setLayoutCount_ = 0,
+                                const vk::DescriptorSetLayout* pSetLayouts_ = nullptr,
+                                uint32_t pushConstantRangeCount_ = 0,
+                                const vk::PushConstantRange* pPushConstantRanges_ = nullptr )
+        : flags( flags_ )
+        , setLayoutCount( setLayoutCount_ )
+        , pSetLayouts( pSetLayouts_ )
+        , pushConstantRangeCount( pushConstantRangeCount_ )
+        , pPushConstantRanges( pPushConstantRanges_ )
+      {}
 
-  struct PipelineLayoutCreateInfo
+      PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this) = rhs;
+      }
+
+      PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineLayoutCreateInfo;
+      const void* pNext = nullptr;
+      vk::PipelineLayoutCreateFlags flags;
+      uint32_t setLayoutCount;
+      const vk::DescriptorSetLayout* pSetLayouts;
+      uint32_t pushConstantRangeCount;
+      const vk::PushConstantRange* pPushConstantRanges;
+    };
+    static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineLayoutCreateInfo : public layout::PipelineLayoutCreateInfo
   {
-    PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(),
+    PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(),
                               uint32_t setLayoutCount_ = 0,
-                              const DescriptorSetLayout* pSetLayouts_ = nullptr,
+                              const vk::DescriptorSetLayout* pSetLayouts_ = nullptr,
                               uint32_t pushConstantRangeCount_ = 0,
-                              const PushConstantRange* pPushConstantRanges_ = nullptr )
-      : flags( flags_ )
-      , setLayoutCount( setLayoutCount_ )
-      , pSetLayouts( pSetLayouts_ )
-      , pushConstantRangeCount( pushConstantRangeCount_ )
-      , pPushConstantRanges( pPushConstantRanges_ )
+                              const vk::PushConstantRange* pPushConstantRanges_ = nullptr )
+      : layout::PipelineLayoutCreateInfo( flags_, setLayoutCount_, pSetLayouts_, pushConstantRangeCount_, pPushConstantRanges_ )
     {}
 
     PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this) = rhs;
-    }
+      : layout::PipelineLayoutCreateInfo( rhs )
+    {}
 
     PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
     {
@@ -43056,7 +52686,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineLayoutCreateInfo & setFlags( PipelineLayoutCreateFlags flags_ )
+    PipelineLayoutCreateInfo & setFlags( vk::PipelineLayoutCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -43068,7 +52698,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineLayoutCreateInfo & setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+    PipelineLayoutCreateInfo & setPSetLayouts( const vk::DescriptorSetLayout* pSetLayouts_ )
     {
       pSetLayouts = pSetLayouts_;
       return *this;
@@ -43080,7 +52710,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineLayoutCreateInfo & setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
+    PipelineLayoutCreateInfo & setPPushConstantRanges( const vk::PushConstantRange* pPushConstantRanges_ )
     {
       pPushConstantRanges = pPushConstantRanges_;
       return *this;
@@ -43113,32 +52743,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineLayoutCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineLayoutCreateFlags flags;
-    uint32_t setLayoutCount;
-    const DescriptorSetLayout* pSetLayouts;
-    uint32_t pushConstantRangeCount;
-    const PushConstantRange* pPushConstantRanges;
+    using layout::PipelineLayoutCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineRasterizationConservativeStateCreateInfoEXT
+    {
+    protected:
+      PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(),
+                                                           vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled,
+                                                           float extraPrimitiveOverestimationSize_ = 0 )
+        : flags( flags_ )
+        , conservativeRasterizationMode( conservativeRasterizationMode_ )
+        , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
+      {}
 
-  struct PipelineRasterizationConservativeStateCreateInfoEXT
+      PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags;
+      vk::ConservativeRasterizationModeEXT conservativeRasterizationMode;
+      float extraPrimitiveOverestimationSize;
+    };
+    static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineRasterizationConservativeStateCreateInfoEXT : public layout::PipelineRasterizationConservativeStateCreateInfoEXT
   {
-    PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(),
-                                                         ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled,
+    PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(),
+                                                         vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled,
                                                          float extraPrimitiveOverestimationSize_ = 0 )
-      : flags( flags_ )
-      , conservativeRasterizationMode( conservativeRasterizationMode_ )
-      , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
+      : layout::PipelineRasterizationConservativeStateCreateInfoEXT( flags_, conservativeRasterizationMode_, extraPrimitiveOverestimationSize_ )
     {}
 
     PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::PipelineRasterizationConservativeStateCreateInfoEXT( rhs )
+    {}
 
     PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
     {
@@ -43152,13 +52806,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineRasterizationConservativeStateCreateInfoEXT & setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
+    PipelineRasterizationConservativeStateCreateInfoEXT & setFlags( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineRasterizationConservativeStateCreateInfoEXT & setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
+    PipelineRasterizationConservativeStateCreateInfoEXT & setConservativeRasterizationMode( vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
     {
       conservativeRasterizationMode = conservativeRasterizationMode_;
       return *this;
@@ -43195,28 +52849,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineRasterizationConservativeStateCreateFlagsEXT flags;
-    ConservativeRasterizationModeEXT conservativeRasterizationMode;
-    float extraPrimitiveOverestimationSize;
+    using layout::PipelineRasterizationConservativeStateCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineRasterizationDepthClipStateCreateInfoEXT
+    {
+    protected:
+      PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(),
+                                                        vk::Bool32 depthClipEnable_ = 0 )
+        : flags( flags_ )
+        , depthClipEnable( depthClipEnable_ )
+      {}
+
+      PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags;
+      vk::Bool32 depthClipEnable;
+    };
+    static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineRasterizationDepthClipStateCreateInfoEXT
+  struct PipelineRasterizationDepthClipStateCreateInfoEXT : public layout::PipelineRasterizationDepthClipStateCreateInfoEXT
   {
-    PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = PipelineRasterizationDepthClipStateCreateFlagsEXT(),
-                                                      Bool32 depthClipEnable_ = 0 )
-      : flags( flags_ )
-      , depthClipEnable( depthClipEnable_ )
+    PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(),
+                                                      vk::Bool32 depthClipEnable_ = 0 )
+      : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( flags_, depthClipEnable_ )
     {}
 
     PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( rhs )
+    {}
 
     PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs )
     {
@@ -43230,13 +52908,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineRasterizationDepthClipStateCreateInfoEXT & setFlags( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ )
+    PipelineRasterizationDepthClipStateCreateInfoEXT & setFlags( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineRasterizationDepthClipStateCreateInfoEXT & setDepthClipEnable( Bool32 depthClipEnable_ )
+    PipelineRasterizationDepthClipStateCreateInfoEXT & setDepthClipEnable( vk::Bool32 depthClipEnable_ )
     {
       depthClipEnable = depthClipEnable_;
       return *this;
@@ -43266,26 +52944,166 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineRasterizationDepthClipStateCreateFlagsEXT flags;
-    Bool32 depthClipEnable;
+    using layout::PipelineRasterizationDepthClipStateCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineRasterizationLineStateCreateInfoEXT
+    {
+    protected:
+      PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault,
+                                                   vk::Bool32 stippledLineEnable_ = 0,
+                                                   uint32_t lineStippleFactor_ = 0,
+                                                   uint16_t lineStipplePattern_ = 0 )
+        : lineRasterizationMode( lineRasterizationMode_ )
+        , stippledLineEnable( stippledLineEnable_ )
+        , lineStippleFactor( lineStippleFactor_ )
+        , lineStipplePattern( lineStipplePattern_ )
+      {}
+
+      PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::LineRasterizationModeEXT lineRasterizationMode;
+      vk::Bool32 stippledLineEnable;
+      uint32_t lineStippleFactor;
+      uint16_t lineStipplePattern;
+    };
+    static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineRasterizationStateRasterizationOrderAMD
+  struct PipelineRasterizationLineStateCreateInfoEXT : public layout::PipelineRasterizationLineStateCreateInfoEXT
   {
-    PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
-      : rasterizationOrder( rasterizationOrder_ )
+    PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault,
+                                                 vk::Bool32 stippledLineEnable_ = 0,
+                                                 uint32_t lineStippleFactor_ = 0,
+                                                 uint16_t lineStipplePattern_ = 0 )
+      : layout::PipelineRasterizationLineStateCreateInfoEXT( lineRasterizationMode_, stippledLineEnable_, lineStippleFactor_, lineStipplePattern_ )
     {}
 
-    PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+    PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs )
+      : layout::PipelineRasterizationLineStateCreateInfoEXT( rhs )
+    {}
+
+    PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs )
     {
-      *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this) = rhs;
+      *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(this) = rhs;
+      return *this;
+    }
+
+    PipelineRasterizationLineStateCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineRasterizationLineStateCreateInfoEXT & setLineRasterizationMode( vk::LineRasterizationModeEXT lineRasterizationMode_ )
+    {
+      lineRasterizationMode = lineRasterizationMode_;
+      return *this;
+    }
+
+    PipelineRasterizationLineStateCreateInfoEXT & setStippledLineEnable( vk::Bool32 stippledLineEnable_ )
+    {
+      stippledLineEnable = stippledLineEnable_;
+      return *this;
+    }
+
+    PipelineRasterizationLineStateCreateInfoEXT & setLineStippleFactor( uint32_t lineStippleFactor_ )
+    {
+      lineStippleFactor = lineStippleFactor_;
+      return *this;
+    }
+
+    PipelineRasterizationLineStateCreateInfoEXT & setLineStipplePattern( uint16_t lineStipplePattern_ )
+    {
+      lineStipplePattern = lineStipplePattern_;
+      return *this;
+    }
+
+    operator VkPipelineRasterizationLineStateCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>( this );
     }
 
+    operator VkPipelineRasterizationLineStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>( this );
+    }
+
+    bool operator==( PipelineRasterizationLineStateCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( lineRasterizationMode == rhs.lineRasterizationMode )
+          && ( stippledLineEnable == rhs.stippledLineEnable )
+          && ( lineStippleFactor == rhs.lineStippleFactor )
+          && ( lineStipplePattern == rhs.lineStipplePattern );
+    }
+
+    bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PipelineRasterizationLineStateCreateInfoEXT::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PipelineRasterizationStateRasterizationOrderAMD
+    {
+    protected:
+      PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict )
+        : rasterizationOrder( rasterizationOrder_ )
+      {}
+
+      PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this) = rhs;
+      }
+
+      PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
+      const void* pNext = nullptr;
+      vk::RasterizationOrderAMD rasterizationOrder;
+    };
+    static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineRasterizationStateRasterizationOrderAMD : public layout::PipelineRasterizationStateRasterizationOrderAMD
+  {
+    PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict )
+      : layout::PipelineRasterizationStateRasterizationOrderAMD( rasterizationOrder_ )
+    {}
+
+    PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+      : layout::PipelineRasterizationStateRasterizationOrderAMD( rhs )
+    {}
+
     PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
     {
       *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this) = rhs;
@@ -43298,7 +53116,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineRasterizationStateRasterizationOrderAMD & setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
+    PipelineRasterizationStateRasterizationOrderAMD & setRasterizationOrder( vk::RasterizationOrderAMD rasterizationOrder_ )
     {
       rasterizationOrder = rasterizationOrder_;
       return *this;
@@ -43327,26 +53145,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
-
-  public:
-    const void* pNext = nullptr;
-    RasterizationOrderAMD rasterizationOrder;
+    using layout::PipelineRasterizationStateRasterizationOrderAMD::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineRasterizationStateStreamCreateInfoEXT
+    {
+    protected:
+      PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(),
+                                                     uint32_t rasterizationStream_ = 0 )
+        : flags( flags_ )
+        , rasterizationStream( rasterizationStream_ )
+      {}
+
+      PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::PipelineRasterizationStateStreamCreateFlagsEXT flags;
+      uint32_t rasterizationStream;
+    };
+    static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineRasterizationStateStreamCreateInfoEXT
+  struct PipelineRasterizationStateStreamCreateInfoEXT : public layout::PipelineRasterizationStateStreamCreateInfoEXT
   {
-    PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateFlagsEXT flags_ = PipelineRasterizationStateStreamCreateFlagsEXT(),
+    PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(),
                                                    uint32_t rasterizationStream_ = 0 )
-      : flags( flags_ )
-      , rasterizationStream( rasterizationStream_ )
+      : layout::PipelineRasterizationStateStreamCreateInfoEXT( flags_, rasterizationStream_ )
     {}
 
     PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::PipelineRasterizationStateStreamCreateInfoEXT( rhs )
+    {}
 
     PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
     {
@@ -43360,7 +53204,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineRasterizationStateStreamCreateInfoEXT & setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ )
+    PipelineRasterizationStateStreamCreateInfoEXT & setFlags( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
@@ -43396,25 +53240,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineRasterizationStateStreamCreateFlagsEXT flags;
-    uint32_t rasterizationStream;
+    using layout::PipelineRasterizationStateStreamCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineRepresentativeFragmentTestStateCreateInfoNV
+    {
+    protected:
+      PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 )
+        : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
+      {}
+
+      PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this) = rhs;
+      }
+
+      PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct PipelineRepresentativeFragmentTestStateCreateInfoNV
+    public:
+      vk::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::Bool32 representativeFragmentTestEnable;
+    };
+    static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineRepresentativeFragmentTestStateCreateInfoNV : public layout::PipelineRepresentativeFragmentTestStateCreateInfoNV
   {
-    PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = 0 )
-      : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
+    PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 )
+      : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( representativeFragmentTestEnable_ )
     {}
 
     PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( rhs )
+    {}
 
     PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
     {
@@ -43428,7 +53295,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineRepresentativeFragmentTestStateCreateInfoNV & setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ )
+    PipelineRepresentativeFragmentTestStateCreateInfoNV & setRepresentativeFragmentTestEnable( vk::Bool32 representativeFragmentTestEnable_ )
     {
       representativeFragmentTestEnable = representativeFragmentTestEnable_;
       return *this;
@@ -43457,26 +53324,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 representativeFragmentTestEnable;
+    using layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::sType;
   };
   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!" );
 
-  struct PipelineSampleLocationsStateCreateInfoEXT
+  namespace layout
   {
-    PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0,
-                                               SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : sampleLocationsEnable( sampleLocationsEnable_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
+    struct PipelineSampleLocationsStateCreateInfoEXT
+    {
+    protected:
+      PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0,
+                                                 vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() )
+        : sampleLocationsEnable( sampleLocationsEnable_ )
+        , sampleLocationsInfo( sampleLocationsInfo_ )
+      {}
+
+      PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::Bool32 sampleLocationsEnable;
+      vk::SampleLocationsInfoEXT sampleLocationsInfo;
+    };
+    static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineSampleLocationsStateCreateInfoEXT : public layout::PipelineSampleLocationsStateCreateInfoEXT
+  {
+    PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0,
+                                               vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() )
+      : layout::PipelineSampleLocationsStateCreateInfoEXT( sampleLocationsEnable_, sampleLocationsInfo_ )
     {}
 
     PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::PipelineSampleLocationsStateCreateInfoEXT( rhs )
+    {}
 
     PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
     {
@@ -43490,13 +53383,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsEnable( Bool32 sampleLocationsEnable_ )
+    PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsEnable( vk::Bool32 sampleLocationsEnable_ )
     {
       sampleLocationsEnable = sampleLocationsEnable_;
       return *this;
     }
 
-    PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+    PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( vk::SampleLocationsInfoEXT sampleLocationsInfo_ )
     {
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
@@ -43526,26 +53419,107 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 sampleLocationsEnable;
-    SampleLocationsInfoEXT sampleLocationsInfo;
+    using layout::PipelineSampleLocationsStateCreateInfoEXT::sType;
   };
   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!" );
 
-  struct PipelineTessellationDomainOriginStateCreateInfo
+  namespace layout
   {
-    PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft )
-      : domainOrigin( domainOrigin_ )
-    {}
+    struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
+    {
+    protected:
+      PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( uint32_t requiredSubgroupSize_ = 0 )
+        : requiredSubgroupSize( requiredSubgroupSize_ )
+      {}
 
-    PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+      PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+      void* pNext = nullptr;
+      uint32_t requiredSubgroupSize;
+    };
+    static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT : public layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
+  {
+    operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const&() const
     {
-      *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this) = rhs;
+      return *reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>( this );
+    }
+
+    operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>( this );
     }
 
+    bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( requiredSubgroupSize == rhs.requiredSubgroupSize );
+    }
+
+    bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    using layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::sType;
+  };
+  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!" );
+
+  namespace layout
+  {
+    struct PipelineTessellationDomainOriginStateCreateInfo
+    {
+    protected:
+      PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft )
+        : domainOrigin( domainOrigin_ )
+      {}
+
+      PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this) = rhs;
+      }
+
+      PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
+      const void* pNext = nullptr;
+      vk::TessellationDomainOrigin domainOrigin;
+    };
+    static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineTessellationDomainOriginStateCreateInfo : public layout::PipelineTessellationDomainOriginStateCreateInfo
+  {
+    PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft )
+      : layout::PipelineTessellationDomainOriginStateCreateInfo( domainOrigin_ )
+    {}
+
+    PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+      : layout::PipelineTessellationDomainOriginStateCreateInfo( rhs )
+    {}
+
     PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
     {
       *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this) = rhs;
@@ -43558,7 +53532,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineTessellationDomainOriginStateCreateInfo & setDomainOrigin( TessellationDomainOrigin domainOrigin_ )
+    PipelineTessellationDomainOriginStateCreateInfo & setDomainOrigin( vk::TessellationDomainOrigin domainOrigin_ )
     {
       domainOrigin = domainOrigin_;
       return *this;
@@ -43587,20 +53561,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    TessellationDomainOrigin domainOrigin;
+    using layout::PipelineTessellationDomainOriginStateCreateInfo::sType;
   };
   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!" );
 
   struct VertexInputBindingDivisorDescriptionEXT
   {
     VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = 0,
                                              uint32_t divisor_ = 0 )
-      : binding( binding_ )
-      , divisor( divisor_ )
+        : binding( binding_ )
+        , divisor( divisor_ )
     {}
 
     VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
@@ -43647,23 +53618,54 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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!" );
+
+  namespace layout
+  {
+    struct PipelineVertexInputDivisorStateCreateInfoEXT
+    {
+    protected:
+      PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
+                                                    const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
+        : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
+        , pVertexBindingDivisors( pVertexBindingDivisors_ )
+      {}
+
+      PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this) = rhs;
+      }
+
+      PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
+      const void* pNext = nullptr;
+      uint32_t vertexBindingDivisorCount;
+      const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
+    };
+    static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineVertexInputDivisorStateCreateInfoEXT
+  struct PipelineVertexInputDivisorStateCreateInfoEXT : public layout::PipelineVertexInputDivisorStateCreateInfoEXT
   {
     PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
-                                                  const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
-      : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
-      , pVertexBindingDivisors( pVertexBindingDivisors_ )
+                                                  const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
+      : layout::PipelineVertexInputDivisorStateCreateInfoEXT( vertexBindingDivisorCount_, pVertexBindingDivisors_ )
     {}
 
     PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::PipelineVertexInputDivisorStateCreateInfoEXT( rhs )
+    {}
 
     PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
     {
@@ -43683,7 +53685,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineVertexInputDivisorStateCreateInfoEXT & setPVertexBindingDivisors( const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ )
+    PipelineVertexInputDivisorStateCreateInfoEXT & setPVertexBindingDivisors( const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ )
     {
       pVertexBindingDivisors = pVertexBindingDivisors_;
       return *this;
@@ -43713,29 +53715,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t vertexBindingDivisorCount;
-    const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
+    using layout::PipelineVertexInputDivisorStateCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
+    {
+    protected:
+      PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault,
+                                                          uint32_t customSampleOrderCount_ = 0,
+                                                          const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
+        : sampleOrderType( sampleOrderType_ )
+        , customSampleOrderCount( customSampleOrderCount_ )
+        , pCustomSampleOrders( pCustomSampleOrders_ )
+      {}
+
+      PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this) = rhs;
+      }
+
+      PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
+    public:
+      vk::StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::CoarseSampleOrderTypeNV sampleOrderType;
+      uint32_t customSampleOrderCount;
+      const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders;
+    };
+    static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineViewportCoarseSampleOrderStateCreateInfoNV : public layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV
   {
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault,
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault,
                                                         uint32_t customSampleOrderCount_ = 0,
-                                                        const CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
-      : sampleOrderType( sampleOrderType_ )
-      , customSampleOrderCount( customSampleOrderCount_ )
-      , pCustomSampleOrders( pCustomSampleOrders_ )
+                                                        const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
+      : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( sampleOrderType_, customSampleOrderCount_, pCustomSampleOrders_ )
     {}
 
     PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( rhs )
+    {}
 
     PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
     {
@@ -43749,7 +53778,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ )
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType( vk::CoarseSampleOrderTypeNV sampleOrderType_ )
     {
       sampleOrderType = sampleOrderType_;
       return *this;
@@ -43761,7 +53790,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPCustomSampleOrders( const CoarseSampleOrderCustomNV* pCustomSampleOrders_ )
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPCustomSampleOrders( const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ )
     {
       pCustomSampleOrders = pCustomSampleOrders_;
       return *this;
@@ -43792,28 +53821,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    CoarseSampleOrderTypeNV sampleOrderType;
-    uint32_t customSampleOrderCount;
-    const CoarseSampleOrderCustomNV* pCustomSampleOrders;
+    using layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineViewportExclusiveScissorStateCreateInfoNV
+    {
+    protected:
+      PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
+                                                         const vk::Rect2D* pExclusiveScissors_ = nullptr )
+        : exclusiveScissorCount( exclusiveScissorCount_ )
+        , pExclusiveScissors( pExclusiveScissors_ )
+      {}
 
-  struct PipelineViewportExclusiveScissorStateCreateInfoNV
+      PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this) = rhs;
+      }
+
+      PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
+      const void* pNext = nullptr;
+      uint32_t exclusiveScissorCount;
+      const vk::Rect2D* pExclusiveScissors;
+    };
+    static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineViewportExclusiveScissorStateCreateInfoNV : public layout::PipelineViewportExclusiveScissorStateCreateInfoNV
   {
     PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
-                                                       const Rect2D* pExclusiveScissors_ = nullptr )
-      : exclusiveScissorCount( exclusiveScissorCount_ )
-      , pExclusiveScissors( pExclusiveScissors_ )
+                                                       const vk::Rect2D* pExclusiveScissors_ = nullptr )
+      : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( exclusiveScissorCount_, pExclusiveScissors_ )
     {}
 
     PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( rhs )
+    {}
 
     PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
     {
@@ -43833,7 +53886,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors( const Rect2D* pExclusiveScissors_ )
+    PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors( const vk::Rect2D* pExclusiveScissors_ )
     {
       pExclusiveScissors = pExclusiveScissors_;
       return *this;
@@ -43863,21 +53916,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t exclusiveScissorCount;
-    const Rect2D* pExclusiveScissors;
+    using layout::PipelineViewportExclusiveScissorStateCreateInfoNV::sType;
   };
   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!" );
 
   struct ShadingRatePaletteNV
   {
     ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0,
-                          const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
-      : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
-      , pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
+                          const vk::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
+        : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
+        , pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
     {}
 
     ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs )
@@ -43897,7 +53946,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ShadingRatePaletteNV & setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ )
+    ShadingRatePaletteNV & setPShadingRatePaletteEntries( const vk::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ )
     {
       pShadingRatePaletteEntries = pShadingRatePaletteEntries_;
       return *this;
@@ -43924,25 +53973,58 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t shadingRatePaletteEntryCount;
-    const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries;
+    const vk::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
+  namespace layout
   {
-    PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = 0,
+    struct PipelineViewportShadingRateImageStateCreateInfoNV
+    {
+    protected:
+      PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0,
+                                                         uint32_t viewportCount_ = 0,
+                                                         const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
+        : shadingRateImageEnable( shadingRateImageEnable_ )
+        , viewportCount( viewportCount_ )
+        , pShadingRatePalettes( pShadingRatePalettes_ )
+      {}
+
+      PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this) = rhs;
+      }
+
+      PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::Bool32 shadingRateImageEnable;
+      uint32_t viewportCount;
+      const vk::ShadingRatePaletteNV* pShadingRatePalettes;
+    };
+    static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineViewportShadingRateImageStateCreateInfoNV : public layout::PipelineViewportShadingRateImageStateCreateInfoNV
+  {
+    PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0,
                                                        uint32_t viewportCount_ = 0,
-                                                       const ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
-      : shadingRateImageEnable( shadingRateImageEnable_ )
-      , viewportCount( viewportCount_ )
-      , pShadingRatePalettes( pShadingRatePalettes_ )
+                                                       const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
+      : layout::PipelineViewportShadingRateImageStateCreateInfoNV( shadingRateImageEnable_, viewportCount_, pShadingRatePalettes_ )
     {}
 
     PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineViewportShadingRateImageStateCreateInfoNV( rhs )
+    {}
 
     PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
     {
@@ -43956,7 +54038,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable( Bool32 shadingRateImageEnable_ )
+    PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable( vk::Bool32 shadingRateImageEnable_ )
     {
       shadingRateImageEnable = shadingRateImageEnable_;
       return *this;
@@ -43968,7 +54050,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes( const ShadingRatePaletteNV* pShadingRatePalettes_ )
+    PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes( const vk::ShadingRatePaletteNV* pShadingRatePalettes_ )
     {
       pShadingRatePalettes = pShadingRatePalettes_;
       return *this;
@@ -43999,26 +54081,21 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 shadingRateImageEnable;
-    uint32_t viewportCount;
-    const ShadingRatePaletteNV* pShadingRatePalettes;
+    using layout::PipelineViewportShadingRateImageStateCreateInfoNV::sType;
   };
   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!" );
 
   struct ViewportSwizzleNV
   {
-    ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX,
-                       ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX,
-                       ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX,
-                       ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
-      , w( w_ )
+    ViewportSwizzleNV( vk::ViewportCoordinateSwizzleNV x_ = vk::ViewportCoordinateSwizzleNV::ePositiveX,
+                       vk::ViewportCoordinateSwizzleNV y_ = vk::ViewportCoordinateSwizzleNV::ePositiveX,
+                       vk::ViewportCoordinateSwizzleNV z_ = vk::ViewportCoordinateSwizzleNV::ePositiveX,
+                       vk::ViewportCoordinateSwizzleNV w_ = vk::ViewportCoordinateSwizzleNV::ePositiveX )
+        : x( x_ )
+        , y( y_ )
+        , z( z_ )
+        , w( w_ )
     {}
 
     ViewportSwizzleNV( VkViewportSwizzleNV const & rhs )
@@ -44032,25 +54109,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ViewportSwizzleNV & setX( ViewportCoordinateSwizzleNV x_ )
+    ViewportSwizzleNV & setX( vk::ViewportCoordinateSwizzleNV x_ )
     {
       x = x_;
       return *this;
     }
 
-    ViewportSwizzleNV & setY( ViewportCoordinateSwizzleNV y_ )
+    ViewportSwizzleNV & setY( vk::ViewportCoordinateSwizzleNV y_ )
     {
       y = y_;
       return *this;
     }
 
-    ViewportSwizzleNV & setZ( ViewportCoordinateSwizzleNV z_ )
+    ViewportSwizzleNV & setZ( vk::ViewportCoordinateSwizzleNV z_ )
     {
       z = z_;
       return *this;
     }
 
-    ViewportSwizzleNV & setW( ViewportCoordinateSwizzleNV w_ )
+    ViewportSwizzleNV & setW( vk::ViewportCoordinateSwizzleNV w_ )
     {
       w = w_;
       return *this;
@@ -44079,27 +54156,60 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ViewportCoordinateSwizzleNV x;
-    ViewportCoordinateSwizzleNV y;
-    ViewportCoordinateSwizzleNV z;
-    ViewportCoordinateSwizzleNV w;
+  public:
+    vk::ViewportCoordinateSwizzleNV x;
+    vk::ViewportCoordinateSwizzleNV y;
+    vk::ViewportCoordinateSwizzleNV z;
+    vk::ViewportCoordinateSwizzleNV w;
   };
   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!" );
+
+  namespace layout
+  {
+    struct PipelineViewportSwizzleStateCreateInfoNV
+    {
+    protected:
+      PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(),
+                                                uint32_t viewportCount_ = 0,
+                                                const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
+        : flags( flags_ )
+        , viewportCount( viewportCount_ )
+        , pViewportSwizzles( pViewportSwizzles_ )
+      {}
+
+      PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this) = rhs;
+      }
+
+      PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct PipelineViewportSwizzleStateCreateInfoNV
+    public:
+      vk::StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::PipelineViewportSwizzleStateCreateFlagsNV flags;
+      uint32_t viewportCount;
+      const vk::ViewportSwizzleNV* pViewportSwizzles;
+    };
+    static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PipelineViewportSwizzleStateCreateInfoNV : public layout::PipelineViewportSwizzleStateCreateInfoNV
   {
-    PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(),
+    PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(),
                                               uint32_t viewportCount_ = 0,
-                                              const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
-      : flags( flags_ )
-      , viewportCount( viewportCount_ )
-      , pViewportSwizzles( pViewportSwizzles_ )
+                                              const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
+      : layout::PipelineViewportSwizzleStateCreateInfoNV( flags_, viewportCount_, pViewportSwizzles_ )
     {}
 
     PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineViewportSwizzleStateCreateInfoNV( rhs )
+    {}
 
     PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
     {
@@ -44113,7 +54223,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportSwizzleStateCreateInfoNV & setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ )
+    PipelineViewportSwizzleStateCreateInfoNV & setFlags( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ )
     {
       flags = flags_;
       return *this;
@@ -44125,7 +54235,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportSwizzleStateCreateInfoNV & setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ )
+    PipelineViewportSwizzleStateCreateInfoNV & setPViewportSwizzles( const vk::ViewportSwizzleNV* pViewportSwizzles_ )
     {
       pViewportSwizzles = pViewportSwizzles_;
       return *this;
@@ -44156,22 +54266,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineViewportSwizzleStateCreateFlagsNV flags;
-    uint32_t viewportCount;
-    const ViewportSwizzleNV* pViewportSwizzles;
+    using layout::PipelineViewportSwizzleStateCreateInfoNV::sType;
   };
   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!" );
 
   struct ViewportWScalingNV
   {
     ViewportWScalingNV( float xcoeff_ = 0,
                         float ycoeff_ = 0 )
-      : xcoeff( xcoeff_ )
-      , ycoeff( ycoeff_ )
+        : xcoeff( xcoeff_ )
+        , ycoeff( ycoeff_ )
     {}
 
     ViewportWScalingNV( VkViewportWScalingNV const & rhs )
@@ -44218,25 +54323,58 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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!" );
+
+  namespace layout
+  {
+    struct PipelineViewportWScalingStateCreateInfoNV
+    {
+    protected:
+      PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0,
+                                                 uint32_t viewportCount_ = 0,
+                                                 const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr )
+        : viewportWScalingEnable( viewportWScalingEnable_ )
+        , viewportCount( viewportCount_ )
+        , pViewportWScalings( pViewportWScalings_ )
+      {}
+
+      PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this) = rhs;
+      }
+
+      PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::Bool32 viewportWScalingEnable;
+      uint32_t viewportCount;
+      const vk::ViewportWScalingNV* pViewportWScalings;
+    };
+    static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PipelineViewportWScalingStateCreateInfoNV
+  struct PipelineViewportWScalingStateCreateInfoNV : public layout::PipelineViewportWScalingStateCreateInfoNV
   {
-    PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0,
+    PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0,
                                                uint32_t viewportCount_ = 0,
-                                               const ViewportWScalingNV* pViewportWScalings_ = nullptr )
-      : viewportWScalingEnable( viewportWScalingEnable_ )
-      , viewportCount( viewportCount_ )
-      , pViewportWScalings( pViewportWScalings_ )
+                                               const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr )
+      : layout::PipelineViewportWScalingStateCreateInfoNV( viewportWScalingEnable_, viewportCount_, pViewportWScalings_ )
     {}
 
     PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this) = rhs;
-    }
+      : layout::PipelineViewportWScalingStateCreateInfoNV( rhs )
+    {}
 
     PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
     {
@@ -44250,7 +54388,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportWScalingStateCreateInfoNV & setViewportWScalingEnable( Bool32 viewportWScalingEnable_ )
+    PipelineViewportWScalingStateCreateInfoNV & setViewportWScalingEnable( vk::Bool32 viewportWScalingEnable_ )
     {
       viewportWScalingEnable = viewportWScalingEnable_;
       return *this;
@@ -44262,7 +54400,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PipelineViewportWScalingStateCreateInfoNV & setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ )
+    PipelineViewportWScalingStateCreateInfoNV & setPViewportWScalings( const vk::ViewportWScalingNV* pViewportWScalings_ )
     {
       pViewportWScalings = pViewportWScalings_;
       return *this;
@@ -44293,27 +54431,50 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 viewportWScalingEnable;
-    uint32_t viewportCount;
-    const ViewportWScalingNV* pViewportWScalings;
+    using layout::PipelineViewportWScalingStateCreateInfoNV::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_GGP
-  struct PresentFrameTokenGGP
+
+  namespace layout
+  {
+    struct PresentFrameTokenGGP
+    {
+    protected:
+      PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 )
+        : frameToken( frameToken_ )
+      {}
+
+      PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs )
+      {
+        *reinterpret_cast<VkPresentFrameTokenGGP*>(this) = rhs;
+      }
+
+      PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs )
+      {
+        *reinterpret_cast<VkPresentFrameTokenGGP*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePresentFrameTokenGGP;
+      const void* pNext = nullptr;
+      GgpFrameToken frameToken;
+    };
+    static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PresentFrameTokenGGP : public layout::PresentFrameTokenGGP
   {
     PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 )
-      : frameToken( frameToken_ )
+      : layout::PresentFrameTokenGGP( frameToken_ )
     {}
 
     PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs )
-    {
-      *reinterpret_cast<VkPresentFrameTokenGGP*>(this) = rhs;
-    }
+      : layout::PresentFrameTokenGGP( rhs )
+    {}
 
     PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs )
     {
@@ -44356,35 +54517,69 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePresentFrameTokenGGP;
-
-  public:
-    const void* pNext = nullptr;
-    GgpFrameToken frameToken;
+    using layout::PresentFrameTokenGGP::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_GGP*/
 
-  struct PresentInfoKHR
+  namespace layout
+  {
+    struct PresentInfoKHR
+    {
+    protected:
+      PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
+                      const vk::Semaphore* pWaitSemaphores_ = nullptr,
+                      uint32_t swapchainCount_ = 0,
+                      const vk::SwapchainKHR* pSwapchains_ = nullptr,
+                      const uint32_t* pImageIndices_ = nullptr,
+                      vk::Result* pResults_ = nullptr )
+        : waitSemaphoreCount( waitSemaphoreCount_ )
+        , pWaitSemaphores( pWaitSemaphores_ )
+        , swapchainCount( swapchainCount_ )
+        , pSwapchains( pSwapchains_ )
+        , pImageIndices( pImageIndices_ )
+        , pResults( pResults_ )
+      {}
+
+      PresentInfoKHR( VkPresentInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkPresentInfoKHR*>(this) = rhs;
+      }
+
+      PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkPresentInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePresentInfoKHR;
+      const void* pNext = nullptr;
+      uint32_t waitSemaphoreCount;
+      const vk::Semaphore* pWaitSemaphores;
+      uint32_t swapchainCount;
+      const vk::SwapchainKHR* pSwapchains;
+      const uint32_t* pImageIndices;
+      vk::Result* pResults;
+    };
+    static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PresentInfoKHR : public layout::PresentInfoKHR
   {
     PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
-                    const Semaphore* pWaitSemaphores_ = nullptr,
+                    const vk::Semaphore* pWaitSemaphores_ = nullptr,
                     uint32_t swapchainCount_ = 0,
-                    const SwapchainKHR* pSwapchains_ = nullptr,
+                    const vk::SwapchainKHR* pSwapchains_ = nullptr,
                     const uint32_t* pImageIndices_ = nullptr,
-                    Result* pResults_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , swapchainCount( swapchainCount_ )
-      , pSwapchains( pSwapchains_ )
-      , pImageIndices( pImageIndices_ )
-      , pResults( pResults_ )
+                    vk::Result* pResults_ = nullptr )
+      : layout::PresentInfoKHR( waitSemaphoreCount_, pWaitSemaphores_, swapchainCount_, pSwapchains_, pImageIndices_, pResults_ )
     {}
 
     PresentInfoKHR( VkPresentInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkPresentInfoKHR*>(this) = rhs;
-    }
+      : layout::PresentInfoKHR( rhs )
+    {}
 
     PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
     {
@@ -44404,7 +54599,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PresentInfoKHR & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+    PresentInfoKHR & setPWaitSemaphores( const vk::Semaphore* pWaitSemaphores_ )
     {
       pWaitSemaphores = pWaitSemaphores_;
       return *this;
@@ -44416,7 +54611,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PresentInfoKHR & setPSwapchains( const SwapchainKHR* pSwapchains_ )
+    PresentInfoKHR & setPSwapchains( const vk::SwapchainKHR* pSwapchains_ )
     {
       pSwapchains = pSwapchains_;
       return *this;
@@ -44428,7 +54623,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PresentInfoKHR & setPResults( Result* pResults_ )
+    PresentInfoKHR & setPResults( vk::Result* pResults_ )
     {
       pResults = pResults_;
       return *this;
@@ -44462,27 +54657,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePresentInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    uint32_t swapchainCount;
-    const SwapchainKHR* pSwapchains;
-    const uint32_t* pImageIndices;
-    Result* pResults;
+    using layout::PresentInfoKHR::sType;
   };
   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!" );
 
   struct RectLayerKHR
   {
-    RectLayerKHR( Offset2D offset_ = Offset2D(),
-                  Extent2D extent_ = Extent2D(),
+    RectLayerKHR( vk::Offset2D offset_ = vk::Offset2D(),
+                  vk::Extent2D extent_ = vk::Extent2D(),
                   uint32_t layer_ = 0 )
-      : offset( offset_ )
-      , extent( extent_ )
-      , layer( layer_ )
+        : offset( offset_ )
+        , extent( extent_ )
+        , layer( layer_ )
     {}
 
     explicit RectLayerKHR( Rect2D const& rect2D,
@@ -44490,6 +54677,7 @@ namespace VULKAN_HPP_NAMESPACE
       : offset( rect2D.offset )
       , extent( rect2D.extent )
       , layer( layer_ )
+
     {}
 
     RectLayerKHR( VkRectLayerKHR const & rhs )
@@ -44503,13 +54691,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RectLayerKHR & setOffset( Offset2D offset_ )
+    RectLayerKHR & setOffset( vk::Offset2D offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    RectLayerKHR & setExtent( Extent2D extent_ )
+    RectLayerKHR & setExtent( vk::Extent2D extent_ )
     {
       extent = extent_;
       return *this;
@@ -44543,18 +54731,20 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Offset2D offset;
-    Extent2D extent;
+  public:
+    vk::Offset2D offset;
+    vk::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
   {
     PresentRegionKHR( uint32_t rectangleCount_ = 0,
-                      const RectLayerKHR* pRectangles_ = nullptr )
-      : rectangleCount( rectangleCount_ )
-      , pRectangles( pRectangles_ )
+                      const vk::RectLayerKHR* pRectangles_ = nullptr )
+        : rectangleCount( rectangleCount_ )
+        , pRectangles( pRectangles_ )
     {}
 
     PresentRegionKHR( VkPresentRegionKHR const & rhs )
@@ -44574,7 +54764,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PresentRegionKHR & setPRectangles( const RectLayerKHR* pRectangles_ )
+    PresentRegionKHR & setPRectangles( const vk::RectLayerKHR* pRectangles_ )
     {
       pRectangles = pRectangles_;
       return *this;
@@ -44601,23 +54791,54 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t rectangleCount;
-    const RectLayerKHR* pRectangles;
+    const vk::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!" );
+
+  namespace layout
+  {
+    struct PresentRegionsKHR
+    {
+    protected:
+      PresentRegionsKHR( uint32_t swapchainCount_ = 0,
+                         const vk::PresentRegionKHR* pRegions_ = nullptr )
+        : swapchainCount( swapchainCount_ )
+        , pRegions( pRegions_ )
+      {}
+
+      PresentRegionsKHR( VkPresentRegionsKHR const & rhs )
+      {
+        *reinterpret_cast<VkPresentRegionsKHR*>(this) = rhs;
+      }
+
+      PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs )
+      {
+        *reinterpret_cast<VkPresentRegionsKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePresentRegionsKHR;
+      const void* pNext = nullptr;
+      uint32_t swapchainCount;
+      const vk::PresentRegionKHR* pRegions;
+    };
+    static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct PresentRegionsKHR
+  struct PresentRegionsKHR : public layout::PresentRegionsKHR
   {
     PresentRegionsKHR( uint32_t swapchainCount_ = 0,
-                       const PresentRegionKHR* pRegions_ = nullptr )
-      : swapchainCount( swapchainCount_ )
-      , pRegions( pRegions_ )
+                       const vk::PresentRegionKHR* pRegions_ = nullptr )
+      : layout::PresentRegionsKHR( swapchainCount_, pRegions_ )
     {}
 
     PresentRegionsKHR( VkPresentRegionsKHR const & rhs )
-    {
-      *reinterpret_cast<VkPresentRegionsKHR*>(this) = rhs;
-    }
+      : layout::PresentRegionsKHR( rhs )
+    {}
 
     PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs )
     {
@@ -44637,7 +54858,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PresentRegionsKHR & setPRegions( const PresentRegionKHR* pRegions_ )
+    PresentRegionsKHR & setPRegions( const vk::PresentRegionKHR* pRegions_ )
     {
       pRegions = pRegions_;
       return *this;
@@ -44667,21 +54888,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePresentRegionsKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const PresentRegionKHR* pRegions;
+    using layout::PresentRegionsKHR::sType;
   };
   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!" );
 
   struct PresentTimeGOOGLE
   {
     PresentTimeGOOGLE( uint32_t presentID_ = 0,
                        uint64_t desiredPresentTime_ = 0 )
-      : presentID( presentID_ )
-      , desiredPresentTime( desiredPresentTime_ )
+        : presentID( presentID_ )
+        , desiredPresentTime( desiredPresentTime_ )
     {}
 
     PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs )
@@ -44728,23 +54945,54 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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!" );
+
+  namespace layout
+  {
+    struct PresentTimesInfoGOOGLE
+    {
+    protected:
+      PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
+                              const vk::PresentTimeGOOGLE* pTimes_ = nullptr )
+        : swapchainCount( swapchainCount_ )
+        , pTimes( pTimes_ )
+      {}
 
-  struct PresentTimesInfoGOOGLE
+      PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs )
+      {
+        *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this) = rhs;
+      }
+
+      PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs )
+      {
+        *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
+      const void* pNext = nullptr;
+      uint32_t swapchainCount;
+      const vk::PresentTimeGOOGLE* pTimes;
+    };
+    static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "layout struct and wrapper have different size!" );
+  }
+
+  struct PresentTimesInfoGOOGLE : public layout::PresentTimesInfoGOOGLE
   {
     PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
-                            const PresentTimeGOOGLE* pTimes_ = nullptr )
-      : swapchainCount( swapchainCount_ )
-      , pTimes( pTimes_ )
+                            const vk::PresentTimeGOOGLE* pTimes_ = nullptr )
+      : layout::PresentTimesInfoGOOGLE( swapchainCount_, pTimes_ )
     {}
 
     PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs )
-    {
-      *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this) = rhs;
-    }
+      : layout::PresentTimesInfoGOOGLE( rhs )
+    {}
 
     PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs )
     {
@@ -44764,7 +55012,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    PresentTimesInfoGOOGLE & setPTimes( const PresentTimeGOOGLE* pTimes_ )
+    PresentTimesInfoGOOGLE & setPTimes( const vk::PresentTimeGOOGLE* pTimes_ )
     {
       pTimes = pTimes_;
       return *this;
@@ -44794,25 +55042,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const PresentTimeGOOGLE* pTimes;
+    using layout::PresentTimesInfoGOOGLE::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ProtectedSubmitInfo
+    {
+    protected:
+      ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 )
+        : protectedSubmit( protectedSubmit_ )
+      {}
+
+      ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs )
+      {
+        *reinterpret_cast<VkProtectedSubmitInfo*>(this) = rhs;
+      }
+
+      ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs )
+      {
+        *reinterpret_cast<VkProtectedSubmitInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eProtectedSubmitInfo;
+      const void* pNext = nullptr;
+      vk::Bool32 protectedSubmit;
+    };
+    static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ProtectedSubmitInfo
+  struct ProtectedSubmitInfo : public layout::ProtectedSubmitInfo
   {
-    ProtectedSubmitInfo( Bool32 protectedSubmit_ = 0 )
-      : protectedSubmit( protectedSubmit_ )
+    ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 )
+      : layout::ProtectedSubmitInfo( protectedSubmit_ )
     {}
 
     ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs )
-    {
-      *reinterpret_cast<VkProtectedSubmitInfo*>(this) = rhs;
-    }
+      : layout::ProtectedSubmitInfo( rhs )
+    {}
 
     ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs )
     {
@@ -44826,7 +55097,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ProtectedSubmitInfo & setProtectedSubmit( Bool32 protectedSubmit_ )
+    ProtectedSubmitInfo & setProtectedSubmit( vk::Bool32 protectedSubmit_ )
     {
       protectedSubmit = protectedSubmit_;
       return *this;
@@ -44855,30 +55126,60 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eProtectedSubmitInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 protectedSubmit;
+    using layout::ProtectedSubmitInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct QueryPoolCreateInfo
+    {
+    protected:
+      QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(),
+                           vk::QueryType queryType_ = vk::QueryType::eOcclusion,
+                           uint32_t queryCount_ = 0,
+                           vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() )
+        : flags( flags_ )
+        , queryType( queryType_ )
+        , queryCount( queryCount_ )
+        , pipelineStatistics( pipelineStatistics_ )
+      {}
+
+      QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkQueryPoolCreateInfo*>(this) = rhs;
+      }
+
+      QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkQueryPoolCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eQueryPoolCreateInfo;
+      const void* pNext = nullptr;
+      vk::QueryPoolCreateFlags flags;
+      vk::QueryType queryType;
+      uint32_t queryCount;
+      vk::QueryPipelineStatisticFlags pipelineStatistics;
+    };
+    static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct QueryPoolCreateInfo
+  struct QueryPoolCreateInfo : public layout::QueryPoolCreateInfo
   {
-    QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(),
-                         QueryType queryType_ = QueryType::eOcclusion,
+    QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(),
+                         vk::QueryType queryType_ = vk::QueryType::eOcclusion,
                          uint32_t queryCount_ = 0,
-                         QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
-      : flags( flags_ )
-      , queryType( queryType_ )
-      , queryCount( queryCount_ )
-      , pipelineStatistics( pipelineStatistics_ )
+                         vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() )
+      : layout::QueryPoolCreateInfo( flags_, queryType_, queryCount_, pipelineStatistics_ )
     {}
 
     QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkQueryPoolCreateInfo*>(this) = rhs;
-    }
+      : layout::QueryPoolCreateInfo( rhs )
+    {}
 
     QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
     {
@@ -44892,13 +55193,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    QueryPoolCreateInfo & setFlags( QueryPoolCreateFlags flags_ )
+    QueryPoolCreateInfo & setFlags( vk::QueryPoolCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    QueryPoolCreateInfo & setQueryType( QueryType queryType_ )
+    QueryPoolCreateInfo & setQueryType( vk::QueryType queryType_ )
     {
       queryType = queryType_;
       return *this;
@@ -44910,7 +55211,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    QueryPoolCreateInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+    QueryPoolCreateInfo & setPipelineStatistics( vk::QueryPipelineStatisticFlags pipelineStatistics_ )
     {
       pipelineStatistics = pipelineStatistics_;
       return *this;
@@ -44942,27 +55243,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eQueryPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    QueryPoolCreateFlags flags;
-    QueryType queryType;
-    uint32_t queryCount;
-    QueryPipelineStatisticFlags pipelineStatistics;
+    using layout::QueryPoolCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct QueryPoolCreateInfoINTEL
+    {
+    protected:
+      QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual )
+        : performanceCountersSampling( performanceCountersSampling_ )
+      {}
+
+      QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkQueryPoolCreateInfoINTEL*>(this) = rhs;
+      }
+
+      QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs )
+      {
+        *reinterpret_cast<VkQueryPoolCreateInfoINTEL*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eQueryPoolCreateInfoINTEL;
+      const void* pNext = nullptr;
+      vk::QueryPoolSamplingModeINTEL performanceCountersSampling;
+    };
+    static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "layout struct and wrapper have different size!" );
+  }
 
-  struct QueryPoolCreateInfoINTEL
+  struct QueryPoolCreateInfoINTEL : public layout::QueryPoolCreateInfoINTEL
   {
-    QueryPoolCreateInfoINTEL( QueryPoolSamplingModeINTEL performanceCountersSampling_ = QueryPoolSamplingModeINTEL::eManual )
-      : performanceCountersSampling( performanceCountersSampling_ )
+    QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual )
+      : layout::QueryPoolCreateInfoINTEL( performanceCountersSampling_ )
     {}
 
     QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs )
-    {
-      *reinterpret_cast<VkQueryPoolCreateInfoINTEL*>(this) = rhs;
-    }
+      : layout::QueryPoolCreateInfoINTEL( rhs )
+    {}
 
     QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs )
     {
@@ -44976,7 +55298,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    QueryPoolCreateInfoINTEL & setPerformanceCountersSampling( QueryPoolSamplingModeINTEL performanceCountersSampling_ )
+    QueryPoolCreateInfoINTEL & setPerformanceCountersSampling( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ )
     {
       performanceCountersSampling = performanceCountersSampling_;
       return *this;
@@ -45005,15 +55327,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eQueryPoolCreateInfoINTEL;
-
-  public:
-    const void* pNext = nullptr;
-    QueryPoolSamplingModeINTEL performanceCountersSampling;
+    using layout::QueryPoolCreateInfoINTEL::sType;
   };
   static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<QueryPoolCreateInfoINTEL>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct QueueFamilyCheckpointPropertiesNV
+    {
+    protected:
+      QueueFamilyCheckpointPropertiesNV( vk::PipelineStageFlags checkpointExecutionStageMask_ = vk::PipelineStageFlags() )
+        : checkpointExecutionStageMask( checkpointExecutionStageMask_ )
+      {}
+
+      QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this) = rhs;
+      }
+
+      QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs )
+      {
+        *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct QueueFamilyCheckpointPropertiesNV
+    public:
+      vk::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
+      void* pNext = nullptr;
+      vk::PipelineStageFlags checkpointExecutionStageMask;
+    };
+    static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct QueueFamilyCheckpointPropertiesNV : public layout::QueueFamilyCheckpointPropertiesNV
   {
     operator VkQueueFamilyCheckpointPropertiesNV const&() const
     {
@@ -45038,13 +55385,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    PipelineStageFlags checkpointExecutionStageMask;
+    using layout::QueueFamilyCheckpointPropertiesNV::sType;
   };
   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!" );
 
   struct QueueFamilyProperties
   {
@@ -45071,14 +55415,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    QueueFlags queueFlags;
+  public:
+    vk::QueueFlags queueFlags;
     uint32_t queueCount;
     uint32_t timestampValidBits;
-    Extent3D minImageTransferGranularity;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct QueueFamilyProperties2
+    {
+    protected:
+      QueueFamilyProperties2( vk::QueueFamilyProperties queueFamilyProperties_ = vk::QueueFamilyProperties() )
+        : queueFamilyProperties( queueFamilyProperties_ )
+      {}
 
-  struct QueueFamilyProperties2
+      QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkQueueFamilyProperties2*>(this) = rhs;
+      }
+
+      QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkQueueFamilyProperties2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eQueueFamilyProperties2;
+      void* pNext = nullptr;
+      vk::QueueFamilyProperties queueFamilyProperties;
+    };
+    static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct QueueFamilyProperties2 : public layout::QueueFamilyProperties2
   {
     operator VkQueueFamilyProperties2 const&() const
     {
@@ -45103,32 +55477,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eQueueFamilyProperties2;
-
-  public:
-    void* pNext = nullptr;
-    QueueFamilyProperties queueFamilyProperties;
+    using layout::QueueFamilyProperties2::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct RayTracingShaderGroupCreateInfoNV
+    {
+    protected:
+      RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral,
+                                         uint32_t generalShader_ = 0,
+                                         uint32_t closestHitShader_ = 0,
+                                         uint32_t anyHitShader_ = 0,
+                                         uint32_t intersectionShader_ = 0 )
+        : type( type_ )
+        , generalShader( generalShader_ )
+        , closestHitShader( closestHitShader_ )
+        , anyHitShader( anyHitShader_ )
+        , intersectionShader( intersectionShader_ )
+      {}
 
-  struct RayTracingShaderGroupCreateInfoNV
+      RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this) = rhs;
+      }
+
+      RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::RayTracingShaderGroupTypeNV type;
+      uint32_t generalShader;
+      uint32_t closestHitShader;
+      uint32_t anyHitShader;
+      uint32_t intersectionShader;
+    };
+    static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RayTracingShaderGroupCreateInfoNV : public layout::RayTracingShaderGroupCreateInfoNV
   {
-    RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeNV type_ = RayTracingShaderGroupTypeNV::eGeneral,
+    RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral,
                                        uint32_t generalShader_ = 0,
                                        uint32_t closestHitShader_ = 0,
                                        uint32_t anyHitShader_ = 0,
                                        uint32_t intersectionShader_ = 0 )
-      : type( type_ )
-      , generalShader( generalShader_ )
-      , closestHitShader( closestHitShader_ )
-      , anyHitShader( anyHitShader_ )
-      , intersectionShader( intersectionShader_ )
+      : layout::RayTracingShaderGroupCreateInfoNV( type_, generalShader_, closestHitShader_, anyHitShader_, intersectionShader_ )
     {}
 
     RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this) = rhs;
-    }
+      : layout::RayTracingShaderGroupCreateInfoNV( rhs )
+    {}
 
     RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs )
     {
@@ -45142,7 +55548,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RayTracingShaderGroupCreateInfoNV & setType( RayTracingShaderGroupTypeNV type_ )
+    RayTracingShaderGroupCreateInfoNV & setType( vk::RayTracingShaderGroupTypeNV type_ )
     {
       type = type_;
       return *this;
@@ -45199,44 +55605,80 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    RayTracingShaderGroupTypeNV type;
-    uint32_t generalShader;
-    uint32_t closestHitShader;
-    uint32_t anyHitShader;
-    uint32_t intersectionShader;
+    using layout::RayTracingShaderGroupCreateInfoNV::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct RayTracingPipelineCreateInfoNV
+    {
+    protected:
+      RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+                                      uint32_t stageCount_ = 0,
+                                      const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr,
+                                      uint32_t groupCount_ = 0,
+                                      const vk::RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
+                                      uint32_t maxRecursionDepth_ = 0,
+                                      vk::PipelineLayout layout_ = vk::PipelineLayout(),
+                                      vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+                                      int32_t basePipelineIndex_ = 0 )
+        : flags( flags_ )
+        , stageCount( stageCount_ )
+        , pStages( pStages_ )
+        , groupCount( groupCount_ )
+        , pGroups( pGroups_ )
+        , maxRecursionDepth( maxRecursionDepth_ )
+        , layout( layout_ )
+        , basePipelineHandle( basePipelineHandle_ )
+        , basePipelineIndex( basePipelineIndex_ )
+      {}
+
+      RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this) = rhs;
+      }
+
+      RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV;
+      const void* pNext = nullptr;
+      vk::PipelineCreateFlags flags;
+      uint32_t stageCount;
+      const vk::PipelineShaderStageCreateInfo* pStages;
+      uint32_t groupCount;
+      const vk::RayTracingShaderGroupCreateInfoNV* pGroups;
+      uint32_t maxRecursionDepth;
+      vk::PipelineLayout layout;
+      vk::Pipeline basePipelineHandle;
+      int32_t basePipelineIndex;
+    };
+    static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "layout struct and wrapper have different size!" );
+  }
 
-  struct RayTracingPipelineCreateInfoNV
+  struct RayTracingPipelineCreateInfoNV : public layout::RayTracingPipelineCreateInfoNV
   {
-    RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = PipelineCreateFlags(),
+    RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
                                     uint32_t stageCount_ = 0,
-                                    const PipelineShaderStageCreateInfo* pStages_ = nullptr,
+                                    const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr,
                                     uint32_t groupCount_ = 0,
-                                    const RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
+                                    const vk::RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
                                     uint32_t maxRecursionDepth_ = 0,
-                                    PipelineLayout layout_ = PipelineLayout(),
-                                    Pipeline basePipelineHandle_ = Pipeline(),
+                                    vk::PipelineLayout layout_ = vk::PipelineLayout(),
+                                    vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
                                     int32_t basePipelineIndex_ = 0 )
-      : flags( flags_ )
-      , stageCount( stageCount_ )
-      , pStages( pStages_ )
-      , groupCount( groupCount_ )
-      , pGroups( pGroups_ )
-      , maxRecursionDepth( maxRecursionDepth_ )
-      , layout( layout_ )
-      , basePipelineHandle( basePipelineHandle_ )
-      , basePipelineIndex( basePipelineIndex_ )
+      : layout::RayTracingPipelineCreateInfoNV( flags_, stageCount_, pStages_, groupCount_, pGroups_, maxRecursionDepth_, layout_, basePipelineHandle_, basePipelineIndex_ )
     {}
 
     RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this) = rhs;
-    }
+      : layout::RayTracingPipelineCreateInfoNV( rhs )
+    {}
 
     RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs )
     {
@@ -45250,7 +55692,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV & setFlags( PipelineCreateFlags flags_ )
+    RayTracingPipelineCreateInfoNV & setFlags( vk::PipelineCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -45262,7 +55704,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV & setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+    RayTracingPipelineCreateInfoNV & setPStages( const vk::PipelineShaderStageCreateInfo* pStages_ )
     {
       pStages = pStages_;
       return *this;
@@ -45274,7 +55716,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV & setPGroups( const RayTracingShaderGroupCreateInfoNV* pGroups_ )
+    RayTracingPipelineCreateInfoNV & setPGroups( const vk::RayTracingShaderGroupCreateInfoNV* pGroups_ )
     {
       pGroups = pGroups_;
       return *this;
@@ -45286,13 +55728,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV & setLayout( PipelineLayout layout_ )
+    RayTracingPipelineCreateInfoNV & setLayout( vk::PipelineLayout layout_ )
     {
       layout = layout_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+    RayTracingPipelineCreateInfoNV & setBasePipelineHandle( vk::Pipeline basePipelineHandle_ )
     {
       basePipelineHandle = basePipelineHandle_;
       return *this;
@@ -45335,21 +55777,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCreateFlags flags;
-    uint32_t stageCount;
-    const PipelineShaderStageCreateInfo* pStages;
-    uint32_t groupCount;
-    const RayTracingShaderGroupCreateInfoNV* pGroups;
-    uint32_t maxRecursionDepth;
-    PipelineLayout layout;
-    Pipeline basePipelineHandle;
-    int32_t basePipelineIndex;
+    using layout::RayTracingPipelineCreateInfoNV::sType;
   };
   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!" );
 
   struct RefreshCycleDurationGOOGLE
   {
@@ -45373,22 +55804,53 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  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!" );
+
+  namespace layout
+  {
+    struct RenderPassAttachmentBeginInfoKHR
+    {
+    protected:
+      RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0,
+                                        const vk::ImageView* pAttachments_ = nullptr )
+        : attachmentCount( attachmentCount_ )
+        , pAttachments( pAttachments_ )
+      {}
+
+      RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
+      }
+
+      RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct RenderPassAttachmentBeginInfoKHR
+    public:
+      vk::StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR;
+      const void* pNext = nullptr;
+      uint32_t attachmentCount;
+      const vk::ImageView* pAttachments;
+    };
+    static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RenderPassAttachmentBeginInfoKHR : public layout::RenderPassAttachmentBeginInfoKHR
   {
     RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0,
-                                      const ImageView* pAttachments_ = nullptr )
-      : attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
+                                      const vk::ImageView* pAttachments_ = nullptr )
+      : layout::RenderPassAttachmentBeginInfoKHR( attachmentCount_, pAttachments_ )
     {}
 
     RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
-    }
+      : layout::RenderPassAttachmentBeginInfoKHR( rhs )
+    {}
 
     RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs )
     {
@@ -45408,7 +55870,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassAttachmentBeginInfoKHR & setPAttachments( const ImageView* pAttachments_ )
+    RenderPassAttachmentBeginInfoKHR & setPAttachments( const vk::ImageView* pAttachments_ )
     {
       pAttachments = pAttachments_;
       return *this;
@@ -45438,33 +55900,64 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t attachmentCount;
-    const ImageView* pAttachments;
+    using layout::RenderPassAttachmentBeginInfoKHR::sType;
   };
   static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<RenderPassAttachmentBeginInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct RenderPassBeginInfo
+    {
+    protected:
+      RenderPassBeginInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
+                           vk::Framebuffer framebuffer_ = vk::Framebuffer(),
+                           vk::Rect2D renderArea_ = vk::Rect2D(),
+                           uint32_t clearValueCount_ = 0,
+                           const vk::ClearValue* pClearValues_ = nullptr )
+        : renderPass( renderPass_ )
+        , framebuffer( framebuffer_ )
+        , renderArea( renderArea_ )
+        , clearValueCount( clearValueCount_ )
+        , pClearValues( pClearValues_ )
+      {}
 
-  struct RenderPassBeginInfo
+      RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassBeginInfo*>(this) = rhs;
+      }
+
+      RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassBeginInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRenderPassBeginInfo;
+      const void* pNext = nullptr;
+      vk::RenderPass renderPass;
+      vk::Framebuffer framebuffer;
+      vk::Rect2D renderArea;
+      uint32_t clearValueCount;
+      const vk::ClearValue* pClearValues;
+    };
+    static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RenderPassBeginInfo : public layout::RenderPassBeginInfo
   {
-    RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(),
-                         Framebuffer framebuffer_ = Framebuffer(),
-                         Rect2D renderArea_ = Rect2D(),
+    RenderPassBeginInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
+                         vk::Framebuffer framebuffer_ = vk::Framebuffer(),
+                         vk::Rect2D renderArea_ = vk::Rect2D(),
                          uint32_t clearValueCount_ = 0,
-                         const ClearValue* pClearValues_ = nullptr )
-      : renderPass( renderPass_ )
-      , framebuffer( framebuffer_ )
-      , renderArea( renderArea_ )
-      , clearValueCount( clearValueCount_ )
-      , pClearValues( pClearValues_ )
+                         const vk::ClearValue* pClearValues_ = nullptr )
+      : layout::RenderPassBeginInfo( renderPass_, framebuffer_, renderArea_, clearValueCount_, pClearValues_ )
     {}
 
     RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
-    {
-      *reinterpret_cast<VkRenderPassBeginInfo*>(this) = rhs;
-    }
+      : layout::RenderPassBeginInfo( rhs )
+    {}
 
     RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
     {
@@ -45478,19 +55971,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassBeginInfo & setRenderPass( RenderPass renderPass_ )
+    RenderPassBeginInfo & setRenderPass( vk::RenderPass renderPass_ )
     {
       renderPass = renderPass_;
       return *this;
     }
 
-    RenderPassBeginInfo & setFramebuffer( Framebuffer framebuffer_ )
+    RenderPassBeginInfo & setFramebuffer( vk::Framebuffer framebuffer_ )
     {
       framebuffer = framebuffer_;
       return *this;
     }
 
-    RenderPassBeginInfo & setRenderArea( Rect2D renderArea_ )
+    RenderPassBeginInfo & setRenderArea( vk::Rect2D renderArea_ )
     {
       renderArea = renderArea_;
       return *this;
@@ -45502,7 +55995,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassBeginInfo & setPClearValues( const ClearValue* pClearValues_ )
+    RenderPassBeginInfo & setPClearValues( const vk::ClearValue* pClearValues_ )
     {
       pClearValues = pClearValues_;
       return *this;
@@ -45535,40 +56028,33 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPass renderPass;
-    Framebuffer framebuffer;
-    Rect2D renderArea;
-    uint32_t clearValueCount;
-    const ClearValue* pClearValues;
+    using layout::RenderPassBeginInfo::sType;
   };
   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!" );
 
   struct SubpassDescription
   {
-    SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(),
-                        PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+    SubpassDescription( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(),
+                        vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
                         uint32_t inputAttachmentCount_ = 0,
-                        const AttachmentReference* pInputAttachments_ = nullptr,
+                        const vk::AttachmentReference* pInputAttachments_ = nullptr,
                         uint32_t colorAttachmentCount_ = 0,
-                        const AttachmentReference* pColorAttachments_ = nullptr,
-                        const AttachmentReference* pResolveAttachments_ = nullptr,
-                        const AttachmentReference* pDepthStencilAttachment_ = nullptr,
+                        const vk::AttachmentReference* pColorAttachments_ = nullptr,
+                        const vk::AttachmentReference* pResolveAttachments_ = nullptr,
+                        const vk::AttachmentReference* pDepthStencilAttachment_ = nullptr,
                         uint32_t preserveAttachmentCount_ = 0,
                         const uint32_t* pPreserveAttachments_ = nullptr )
-      : flags( flags_ )
-      , pipelineBindPoint( pipelineBindPoint_ )
-      , inputAttachmentCount( inputAttachmentCount_ )
-      , pInputAttachments( pInputAttachments_ )
-      , colorAttachmentCount( colorAttachmentCount_ )
-      , pColorAttachments( pColorAttachments_ )
-      , pResolveAttachments( pResolveAttachments_ )
-      , pDepthStencilAttachment( pDepthStencilAttachment_ )
-      , preserveAttachmentCount( preserveAttachmentCount_ )
-      , pPreserveAttachments( pPreserveAttachments_ )
+        : flags( flags_ )
+        , pipelineBindPoint( pipelineBindPoint_ )
+        , inputAttachmentCount( inputAttachmentCount_ )
+        , pInputAttachments( pInputAttachments_ )
+        , colorAttachmentCount( colorAttachmentCount_ )
+        , pColorAttachments( pColorAttachments_ )
+        , pResolveAttachments( pResolveAttachments_ )
+        , pDepthStencilAttachment( pDepthStencilAttachment_ )
+        , preserveAttachmentCount( preserveAttachmentCount_ )
+        , pPreserveAttachments( pPreserveAttachments_ )
     {}
 
     SubpassDescription( VkSubpassDescription const & rhs )
@@ -45582,13 +56068,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDescription & setFlags( SubpassDescriptionFlags flags_ )
+    SubpassDescription & setFlags( vk::SubpassDescriptionFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    SubpassDescription & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    SubpassDescription & setPipelineBindPoint( vk::PipelineBindPoint pipelineBindPoint_ )
     {
       pipelineBindPoint = pipelineBindPoint_;
       return *this;
@@ -45600,7 +56086,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDescription & setPInputAttachments( const AttachmentReference* pInputAttachments_ )
+    SubpassDescription & setPInputAttachments( const vk::AttachmentReference* pInputAttachments_ )
     {
       pInputAttachments = pInputAttachments_;
       return *this;
@@ -45612,19 +56098,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDescription & setPColorAttachments( const AttachmentReference* pColorAttachments_ )
+    SubpassDescription & setPColorAttachments( const vk::AttachmentReference* pColorAttachments_ )
     {
       pColorAttachments = pColorAttachments_;
       return *this;
     }
 
-    SubpassDescription & setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
+    SubpassDescription & setPResolveAttachments( const vk::AttachmentReference* pResolveAttachments_ )
     {
       pResolveAttachments = pResolveAttachments_;
       return *this;
     }
 
-    SubpassDescription & setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
+    SubpassDescription & setPDepthStencilAttachment( const vk::AttachmentReference* pDepthStencilAttachment_ )
     {
       pDepthStencilAttachment = pDepthStencilAttachment_;
       return *this;
@@ -45671,35 +56157,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    SubpassDescriptionFlags flags;
-    PipelineBindPoint pipelineBindPoint;
+  public:
+    vk::SubpassDescriptionFlags flags;
+    vk::PipelineBindPoint pipelineBindPoint;
     uint32_t inputAttachmentCount;
-    const AttachmentReference* pInputAttachments;
+    const vk::AttachmentReference* pInputAttachments;
     uint32_t colorAttachmentCount;
-    const AttachmentReference* pColorAttachments;
-    const AttachmentReference* pResolveAttachments;
-    const AttachmentReference* pDepthStencilAttachment;
+    const vk::AttachmentReference* pColorAttachments;
+    const vk::AttachmentReference* pResolveAttachments;
+    const vk::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
   {
     SubpassDependency( uint32_t srcSubpass_ = 0,
                        uint32_t dstSubpass_ = 0,
-                       PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
-                       PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
-                       AccessFlags srcAccessMask_ = AccessFlags(),
-                       AccessFlags dstAccessMask_ = AccessFlags(),
-                       DependencyFlags dependencyFlags_ = DependencyFlags() )
-      : srcSubpass( srcSubpass_ )
-      , dstSubpass( dstSubpass_ )
-      , srcStageMask( srcStageMask_ )
-      , dstStageMask( dstStageMask_ )
-      , srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , dependencyFlags( dependencyFlags_ )
+                       vk::PipelineStageFlags srcStageMask_ = vk::PipelineStageFlags(),
+                       vk::PipelineStageFlags dstStageMask_ = vk::PipelineStageFlags(),
+                       vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                       vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+                       vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags() )
+        : srcSubpass( srcSubpass_ )
+        , dstSubpass( dstSubpass_ )
+        , srcStageMask( srcStageMask_ )
+        , dstStageMask( dstStageMask_ )
+        , srcAccessMask( srcAccessMask_ )
+        , dstAccessMask( dstAccessMask_ )
+        , dependencyFlags( dependencyFlags_ )
     {}
 
     SubpassDependency( VkSubpassDependency const & rhs )
@@ -45725,31 +56213,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDependency & setSrcStageMask( PipelineStageFlags srcStageMask_ )
+    SubpassDependency & setSrcStageMask( vk::PipelineStageFlags srcStageMask_ )
     {
       srcStageMask = srcStageMask_;
       return *this;
     }
 
-    SubpassDependency & setDstStageMask( PipelineStageFlags dstStageMask_ )
+    SubpassDependency & setDstStageMask( vk::PipelineStageFlags dstStageMask_ )
     {
       dstStageMask = dstStageMask_;
       return *this;
     }
 
-    SubpassDependency & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    SubpassDependency & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
     {
       srcAccessMask = srcAccessMask_;
       return *this;
     }
 
-    SubpassDependency & setDstAccessMask( AccessFlags dstAccessMask_ )
+    SubpassDependency & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
     {
       dstAccessMask = dstAccessMask_;
       return *this;
     }
 
-    SubpassDependency & setDependencyFlags( DependencyFlags dependencyFlags_ )
+    SubpassDependency & setDependencyFlags( vk::DependencyFlags dependencyFlags_ )
     {
       dependencyFlags = dependencyFlags_;
       return *this;
@@ -45781,38 +56269,79 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t srcSubpass;
     uint32_t dstSubpass;
-    PipelineStageFlags srcStageMask;
-    PipelineStageFlags dstStageMask;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    DependencyFlags dependencyFlags;
+    vk::PipelineStageFlags srcStageMask;
+    vk::PipelineStageFlags dstStageMask;
+    vk::AccessFlags srcAccessMask;
+    vk::AccessFlags dstAccessMask;
+    vk::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
+  namespace layout
   {
-    RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
+    struct RenderPassCreateInfo
+    {
+    protected:
+      RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
+                            uint32_t attachmentCount_ = 0,
+                            const vk::AttachmentDescription* pAttachments_ = nullptr,
+                            uint32_t subpassCount_ = 0,
+                            const vk::SubpassDescription* pSubpasses_ = nullptr,
+                            uint32_t dependencyCount_ = 0,
+                            const vk::SubpassDependency* pDependencies_ = nullptr )
+        : flags( flags_ )
+        , attachmentCount( attachmentCount_ )
+        , pAttachments( pAttachments_ )
+        , subpassCount( subpassCount_ )
+        , pSubpasses( pSubpasses_ )
+        , dependencyCount( dependencyCount_ )
+        , pDependencies( pDependencies_ )
+      {}
+
+      RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassCreateInfo*>(this) = rhs;
+      }
+
+      RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRenderPassCreateInfo;
+      const void* pNext = nullptr;
+      vk::RenderPassCreateFlags flags;
+      uint32_t attachmentCount;
+      const vk::AttachmentDescription* pAttachments;
+      uint32_t subpassCount;
+      const vk::SubpassDescription* pSubpasses;
+      uint32_t dependencyCount;
+      const vk::SubpassDependency* pDependencies;
+    };
+    static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RenderPassCreateInfo : public layout::RenderPassCreateInfo
+  {
+    RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
                           uint32_t attachmentCount_ = 0,
-                          const AttachmentDescription* pAttachments_ = nullptr,
+                          const vk::AttachmentDescription* pAttachments_ = nullptr,
                           uint32_t subpassCount_ = 0,
-                          const SubpassDescription* pSubpasses_ = nullptr,
+                          const vk::SubpassDescription* pSubpasses_ = nullptr,
                           uint32_t dependencyCount_ = 0,
-                          const SubpassDependency* pDependencies_ = nullptr )
-      : flags( flags_ )
-      , attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
-      , subpassCount( subpassCount_ )
-      , pSubpasses( pSubpasses_ )
-      , dependencyCount( dependencyCount_ )
-      , pDependencies( pDependencies_ )
+                          const vk::SubpassDependency* pDependencies_ = nullptr )
+      : layout::RenderPassCreateInfo( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_ )
     {}
 
     RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkRenderPassCreateInfo*>(this) = rhs;
-    }
+      : layout::RenderPassCreateInfo( rhs )
+    {}
 
     RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
     {
@@ -45826,7 +56355,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassCreateInfo & setFlags( RenderPassCreateFlags flags_ )
+    RenderPassCreateInfo & setFlags( vk::RenderPassCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -45838,7 +56367,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassCreateInfo & setPAttachments( const AttachmentDescription* pAttachments_ )
+    RenderPassCreateInfo & setPAttachments( const vk::AttachmentDescription* pAttachments_ )
     {
       pAttachments = pAttachments_;
       return *this;
@@ -45850,7 +56379,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassCreateInfo & setPSubpasses( const SubpassDescription* pSubpasses_ )
+    RenderPassCreateInfo & setPSubpasses( const vk::SubpassDescription* pSubpasses_ )
     {
       pSubpasses = pSubpasses_;
       return *this;
@@ -45862,7 +56391,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassCreateInfo & setPDependencies( const SubpassDependency* pDependencies_ )
+    RenderPassCreateInfo & setPDependencies( const vk::SubpassDependency* pDependencies_ )
     {
       pDependencies = pDependencies_;
       return *this;
@@ -45897,50 +56426,88 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPassCreateFlags flags;
-    uint32_t attachmentCount;
-    const AttachmentDescription* pAttachments;
-    uint32_t subpassCount;
-    const SubpassDescription* pSubpasses;
-    uint32_t dependencyCount;
-    const SubpassDependency* pDependencies;
+    using layout::RenderPassCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct SubpassDescription2KHR
+    {
+    protected:
+      SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(),
+                              vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+                              uint32_t viewMask_ = 0,
+                              uint32_t inputAttachmentCount_ = 0,
+                              const vk::AttachmentReference2KHR* pInputAttachments_ = nullptr,
+                              uint32_t colorAttachmentCount_ = 0,
+                              const vk::AttachmentReference2KHR* pColorAttachments_ = nullptr,
+                              const vk::AttachmentReference2KHR* pResolveAttachments_ = nullptr,
+                              const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
+                              uint32_t preserveAttachmentCount_ = 0,
+                              const uint32_t* pPreserveAttachments_ = nullptr )
+        : flags( flags_ )
+        , pipelineBindPoint( pipelineBindPoint_ )
+        , viewMask( viewMask_ )
+        , inputAttachmentCount( inputAttachmentCount_ )
+        , pInputAttachments( pInputAttachments_ )
+        , colorAttachmentCount( colorAttachmentCount_ )
+        , pColorAttachments( pColorAttachments_ )
+        , pResolveAttachments( pResolveAttachments_ )
+        , pDepthStencilAttachment( pDepthStencilAttachment_ )
+        , preserveAttachmentCount( preserveAttachmentCount_ )
+        , pPreserveAttachments( pPreserveAttachments_ )
+      {}
+
+      SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassDescription2KHR*>(this) = rhs;
+      }
+
+      SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassDescription2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSubpassDescription2KHR;
+      const void* pNext = nullptr;
+      vk::SubpassDescriptionFlags flags;
+      vk::PipelineBindPoint pipelineBindPoint;
+      uint32_t viewMask;
+      uint32_t inputAttachmentCount;
+      const vk::AttachmentReference2KHR* pInputAttachments;
+      uint32_t colorAttachmentCount;
+      const vk::AttachmentReference2KHR* pColorAttachments;
+      const vk::AttachmentReference2KHR* pResolveAttachments;
+      const vk::AttachmentReference2KHR* pDepthStencilAttachment;
+      uint32_t preserveAttachmentCount;
+      const uint32_t* pPreserveAttachments;
+    };
+    static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct SubpassDescription2KHR
+  struct SubpassDescription2KHR : public layout::SubpassDescription2KHR
   {
-    SubpassDescription2KHR( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(),
-                            PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+    SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(),
+                            vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
                             uint32_t viewMask_ = 0,
                             uint32_t inputAttachmentCount_ = 0,
-                            const AttachmentReference2KHR* pInputAttachments_ = nullptr,
+                            const vk::AttachmentReference2KHR* pInputAttachments_ = nullptr,
                             uint32_t colorAttachmentCount_ = 0,
-                            const AttachmentReference2KHR* pColorAttachments_ = nullptr,
-                            const AttachmentReference2KHR* pResolveAttachments_ = nullptr,
-                            const AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
+                            const vk::AttachmentReference2KHR* pColorAttachments_ = nullptr,
+                            const vk::AttachmentReference2KHR* pResolveAttachments_ = nullptr,
+                            const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
                             uint32_t preserveAttachmentCount_ = 0,
                             const uint32_t* pPreserveAttachments_ = nullptr )
-      : flags( flags_ )
-      , pipelineBindPoint( pipelineBindPoint_ )
-      , viewMask( viewMask_ )
-      , inputAttachmentCount( inputAttachmentCount_ )
-      , pInputAttachments( pInputAttachments_ )
-      , colorAttachmentCount( colorAttachmentCount_ )
-      , pColorAttachments( pColorAttachments_ )
-      , pResolveAttachments( pResolveAttachments_ )
-      , pDepthStencilAttachment( pDepthStencilAttachment_ )
-      , preserveAttachmentCount( preserveAttachmentCount_ )
-      , pPreserveAttachments( pPreserveAttachments_ )
+      : layout::SubpassDescription2KHR( flags_, pipelineBindPoint_, viewMask_, inputAttachmentCount_, pInputAttachments_, colorAttachmentCount_, pColorAttachments_, pResolveAttachments_, pDepthStencilAttachment_, preserveAttachmentCount_, pPreserveAttachments_ )
     {}
 
     SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs )
-    {
-      *reinterpret_cast<VkSubpassDescription2KHR*>(this) = rhs;
-    }
+      : layout::SubpassDescription2KHR( rhs )
+    {}
 
     SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs )
     {
@@ -45954,13 +56521,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDescription2KHR & setFlags( SubpassDescriptionFlags flags_ )
+    SubpassDescription2KHR & setFlags( vk::SubpassDescriptionFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    SubpassDescription2KHR & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    SubpassDescription2KHR & setPipelineBindPoint( vk::PipelineBindPoint pipelineBindPoint_ )
     {
       pipelineBindPoint = pipelineBindPoint_;
       return *this;
@@ -45978,7 +56545,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDescription2KHR & setPInputAttachments( const AttachmentReference2KHR* pInputAttachments_ )
+    SubpassDescription2KHR & setPInputAttachments( const vk::AttachmentReference2KHR* pInputAttachments_ )
     {
       pInputAttachments = pInputAttachments_;
       return *this;
@@ -45990,19 +56557,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDescription2KHR & setPColorAttachments( const AttachmentReference2KHR* pColorAttachments_ )
+    SubpassDescription2KHR & setPColorAttachments( const vk::AttachmentReference2KHR* pColorAttachments_ )
     {
       pColorAttachments = pColorAttachments_;
       return *this;
     }
 
-    SubpassDescription2KHR & setPResolveAttachments( const AttachmentReference2KHR* pResolveAttachments_ )
+    SubpassDescription2KHR & setPResolveAttachments( const vk::AttachmentReference2KHR* pResolveAttachments_ )
     {
       pResolveAttachments = pResolveAttachments_;
       return *this;
     }
 
-    SubpassDescription2KHR & setPDepthStencilAttachment( const AttachmentReference2KHR* pDepthStencilAttachment_ )
+    SubpassDescription2KHR & setPDepthStencilAttachment( const vk::AttachmentReference2KHR* pDepthStencilAttachment_ )
     {
       pDepthStencilAttachment = pDepthStencilAttachment_;
       return *this;
@@ -46053,48 +56620,76 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSubpassDescription2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    SubpassDescriptionFlags flags;
-    PipelineBindPoint pipelineBindPoint;
-    uint32_t viewMask;
-    uint32_t inputAttachmentCount;
-    const AttachmentReference2KHR* pInputAttachments;
-    uint32_t colorAttachmentCount;
-    const AttachmentReference2KHR* pColorAttachments;
-    const AttachmentReference2KHR* pResolveAttachments;
-    const AttachmentReference2KHR* pDepthStencilAttachment;
-    uint32_t preserveAttachmentCount;
-    const uint32_t* pPreserveAttachments;
+    using layout::SubpassDescription2KHR::sType;
   };
   static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<SubpassDescription2KHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct SubpassDependency2KHR
+    {
+    protected:
+      SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
+                             uint32_t dstSubpass_ = 0,
+                             vk::PipelineStageFlags srcStageMask_ = vk::PipelineStageFlags(),
+                             vk::PipelineStageFlags dstStageMask_ = vk::PipelineStageFlags(),
+                             vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                             vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+                             vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(),
+                             int32_t viewOffset_ = 0 )
+        : srcSubpass( srcSubpass_ )
+        , dstSubpass( dstSubpass_ )
+        , srcStageMask( srcStageMask_ )
+        , dstStageMask( dstStageMask_ )
+        , srcAccessMask( srcAccessMask_ )
+        , dstAccessMask( dstAccessMask_ )
+        , dependencyFlags( dependencyFlags_ )
+        , viewOffset( viewOffset_ )
+      {}
 
-  struct SubpassDependency2KHR
+      SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassDependency2KHR*>(this) = rhs;
+      }
+
+      SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassDependency2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSubpassDependency2KHR;
+      const void* pNext = nullptr;
+      uint32_t srcSubpass;
+      uint32_t dstSubpass;
+      vk::PipelineStageFlags srcStageMask;
+      vk::PipelineStageFlags dstStageMask;
+      vk::AccessFlags srcAccessMask;
+      vk::AccessFlags dstAccessMask;
+      vk::DependencyFlags dependencyFlags;
+      int32_t viewOffset;
+    };
+    static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SubpassDependency2KHR : public layout::SubpassDependency2KHR
   {
     SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
                            uint32_t dstSubpass_ = 0,
-                           PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
-                           PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
-                           AccessFlags srcAccessMask_ = AccessFlags(),
-                           AccessFlags dstAccessMask_ = AccessFlags(),
-                           DependencyFlags dependencyFlags_ = DependencyFlags(),
+                           vk::PipelineStageFlags srcStageMask_ = vk::PipelineStageFlags(),
+                           vk::PipelineStageFlags dstStageMask_ = vk::PipelineStageFlags(),
+                           vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+                           vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+                           vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(),
                            int32_t viewOffset_ = 0 )
-      : srcSubpass( srcSubpass_ )
-      , dstSubpass( dstSubpass_ )
-      , srcStageMask( srcStageMask_ )
-      , dstStageMask( dstStageMask_ )
-      , srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , dependencyFlags( dependencyFlags_ )
-      , viewOffset( viewOffset_ )
+      : layout::SubpassDependency2KHR( srcSubpass_, dstSubpass_, srcStageMask_, dstStageMask_, srcAccessMask_, dstAccessMask_, dependencyFlags_, viewOffset_ )
     {}
 
     SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs )
-    {
-      *reinterpret_cast<VkSubpassDependency2KHR*>(this) = rhs;
-    }
+      : layout::SubpassDependency2KHR( rhs )
+    {}
 
     SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs )
     {
@@ -46120,31 +56715,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDependency2KHR & setSrcStageMask( PipelineStageFlags srcStageMask_ )
+    SubpassDependency2KHR & setSrcStageMask( vk::PipelineStageFlags srcStageMask_ )
     {
       srcStageMask = srcStageMask_;
       return *this;
     }
 
-    SubpassDependency2KHR & setDstStageMask( PipelineStageFlags dstStageMask_ )
+    SubpassDependency2KHR & setDstStageMask( vk::PipelineStageFlags dstStageMask_ )
     {
       dstStageMask = dstStageMask_;
       return *this;
     }
 
-    SubpassDependency2KHR & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    SubpassDependency2KHR & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
     {
       srcAccessMask = srcAccessMask_;
       return *this;
     }
 
-    SubpassDependency2KHR & setDstAccessMask( AccessFlags dstAccessMask_ )
+    SubpassDependency2KHR & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
     {
       dstAccessMask = dstAccessMask_;
       return *this;
     }
 
-    SubpassDependency2KHR & setDependencyFlags( DependencyFlags dependencyFlags_ )
+    SubpassDependency2KHR & setDependencyFlags( vk::DependencyFlags dependencyFlags_ )
     {
       dependencyFlags = dependencyFlags_;
       return *this;
@@ -46186,47 +56781,80 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSubpassDependency2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t srcSubpass;
-    uint32_t dstSubpass;
-    PipelineStageFlags srcStageMask;
-    PipelineStageFlags dstStageMask;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    DependencyFlags dependencyFlags;
-    int32_t viewOffset;
+    using layout::SubpassDependency2KHR::sType;
   };
   static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<SubpassDependency2KHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct RenderPassCreateInfo2KHR
+    {
+    protected:
+      RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
+                                uint32_t attachmentCount_ = 0,
+                                const vk::AttachmentDescription2KHR* pAttachments_ = nullptr,
+                                uint32_t subpassCount_ = 0,
+                                const vk::SubpassDescription2KHR* pSubpasses_ = nullptr,
+                                uint32_t dependencyCount_ = 0,
+                                const vk::SubpassDependency2KHR* pDependencies_ = nullptr,
+                                uint32_t correlatedViewMaskCount_ = 0,
+                                const uint32_t* pCorrelatedViewMasks_ = nullptr )
+        : flags( flags_ )
+        , attachmentCount( attachmentCount_ )
+        , pAttachments( pAttachments_ )
+        , subpassCount( subpassCount_ )
+        , pSubpasses( pSubpasses_ )
+        , dependencyCount( dependencyCount_ )
+        , pDependencies( pDependencies_ )
+        , correlatedViewMaskCount( correlatedViewMaskCount_ )
+        , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
+      {}
+
+      RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this) = rhs;
+      }
 
-  struct RenderPassCreateInfo2KHR
+      RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRenderPassCreateInfo2KHR;
+      const void* pNext = nullptr;
+      vk::RenderPassCreateFlags flags;
+      uint32_t attachmentCount;
+      const vk::AttachmentDescription2KHR* pAttachments;
+      uint32_t subpassCount;
+      const vk::SubpassDescription2KHR* pSubpasses;
+      uint32_t dependencyCount;
+      const vk::SubpassDependency2KHR* pDependencies;
+      uint32_t correlatedViewMaskCount;
+      const uint32_t* pCorrelatedViewMasks;
+    };
+    static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RenderPassCreateInfo2KHR : public layout::RenderPassCreateInfo2KHR
   {
-    RenderPassCreateInfo2KHR( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
+    RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
                               uint32_t attachmentCount_ = 0,
-                              const AttachmentDescription2KHR* pAttachments_ = nullptr,
+                              const vk::AttachmentDescription2KHR* pAttachments_ = nullptr,
                               uint32_t subpassCount_ = 0,
-                              const SubpassDescription2KHR* pSubpasses_ = nullptr,
+                              const vk::SubpassDescription2KHR* pSubpasses_ = nullptr,
                               uint32_t dependencyCount_ = 0,
-                              const SubpassDependency2KHR* pDependencies_ = nullptr,
+                              const vk::SubpassDependency2KHR* pDependencies_ = nullptr,
                               uint32_t correlatedViewMaskCount_ = 0,
                               const uint32_t* pCorrelatedViewMasks_ = nullptr )
-      : flags( flags_ )
-      , attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
-      , subpassCount( subpassCount_ )
-      , pSubpasses( pSubpasses_ )
-      , dependencyCount( dependencyCount_ )
-      , pDependencies( pDependencies_ )
-      , correlatedViewMaskCount( correlatedViewMaskCount_ )
-      , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
+      : layout::RenderPassCreateInfo2KHR( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_, correlatedViewMaskCount_, pCorrelatedViewMasks_ )
     {}
 
     RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs )
-    {
-      *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this) = rhs;
-    }
+      : layout::RenderPassCreateInfo2KHR( rhs )
+    {}
 
     RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs )
     {
@@ -46240,7 +56868,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassCreateInfo2KHR & setFlags( RenderPassCreateFlags flags_ )
+    RenderPassCreateInfo2KHR & setFlags( vk::RenderPassCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -46252,7 +56880,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassCreateInfo2KHR & setPAttachments( const AttachmentDescription2KHR* pAttachments_ )
+    RenderPassCreateInfo2KHR & setPAttachments( const vk::AttachmentDescription2KHR* pAttachments_ )
     {
       pAttachments = pAttachments_;
       return *this;
@@ -46264,7 +56892,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassCreateInfo2KHR & setPSubpasses( const SubpassDescription2KHR* pSubpasses_ )
+    RenderPassCreateInfo2KHR & setPSubpasses( const vk::SubpassDescription2KHR* pSubpasses_ )
     {
       pSubpasses = pSubpasses_;
       return *this;
@@ -46276,7 +56904,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassCreateInfo2KHR & setPDependencies( const SubpassDependency2KHR* pDependencies_ )
+    RenderPassCreateInfo2KHR & setPDependencies( const vk::SubpassDependency2KHR* pDependencies_ )
     {
       pDependencies = pDependencies_;
       return *this;
@@ -46325,32 +56953,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassCreateInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPassCreateFlags flags;
-    uint32_t attachmentCount;
-    const AttachmentDescription2KHR* pAttachments;
-    uint32_t subpassCount;
-    const SubpassDescription2KHR* pSubpasses;
-    uint32_t dependencyCount;
-    const SubpassDependency2KHR* pDependencies;
-    uint32_t correlatedViewMaskCount;
-    const uint32_t* pCorrelatedViewMasks;
+    using layout::RenderPassCreateInfo2KHR::sType;
   };
   static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<RenderPassCreateInfo2KHR>::value, "struct wrapper is not a standard layout!" );
 
-  struct RenderPassFragmentDensityMapCreateInfoEXT
+  namespace layout
   {
-    RenderPassFragmentDensityMapCreateInfoEXT( AttachmentReference fragmentDensityMapAttachment_ = AttachmentReference() )
-      : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
+    struct RenderPassFragmentDensityMapCreateInfoEXT
+    {
+    protected:
+      RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() )
+        : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
+      {}
+
+      RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this) = rhs;
+      }
+
+      RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::AttachmentReference fragmentDensityMapAttachment;
+    };
+    static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RenderPassFragmentDensityMapCreateInfoEXT : public layout::RenderPassFragmentDensityMapCreateInfoEXT
+  {
+    RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() )
+      : layout::RenderPassFragmentDensityMapCreateInfoEXT( fragmentDensityMapAttachment_ )
     {}
 
     RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::RenderPassFragmentDensityMapCreateInfoEXT( rhs )
+    {}
 
     RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
     {
@@ -46364,7 +57008,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( AttachmentReference fragmentDensityMapAttachment_ )
+    RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( vk::AttachmentReference fragmentDensityMapAttachment_ )
     {
       fragmentDensityMapAttachment = fragmentDensityMapAttachment_;
       return *this;
@@ -46393,26 +57037,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    AttachmentReference fragmentDensityMapAttachment;
+    using layout::RenderPassFragmentDensityMapCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct RenderPassInputAttachmentAspectCreateInfo
+    {
+    protected:
+      RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
+                                                 const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr )
+        : aspectReferenceCount( aspectReferenceCount_ )
+        , pAspectReferences( pAspectReferences_ )
+      {}
+
+      RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this) = rhs;
+      }
 
-  struct RenderPassInputAttachmentAspectCreateInfo
+      RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
+      const void* pNext = nullptr;
+      uint32_t aspectReferenceCount;
+      const vk::InputAttachmentAspectReference* pAspectReferences;
+    };
+    static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RenderPassInputAttachmentAspectCreateInfo : public layout::RenderPassInputAttachmentAspectCreateInfo
   {
     RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
-                                               const InputAttachmentAspectReference* pAspectReferences_ = nullptr )
-      : aspectReferenceCount( aspectReferenceCount_ )
-      , pAspectReferences( pAspectReferences_ )
+                                               const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr )
+      : layout::RenderPassInputAttachmentAspectCreateInfo( aspectReferenceCount_, pAspectReferences_ )
     {}
 
     RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this) = rhs;
-    }
+      : layout::RenderPassInputAttachmentAspectCreateInfo( rhs )
+    {}
 
     RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
     {
@@ -46432,7 +57102,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences( const InputAttachmentAspectReference* pAspectReferences_ )
+    RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences( const vk::InputAttachmentAspectReference* pAspectReferences_ )
     {
       pAspectReferences = pAspectReferences_;
       return *this;
@@ -46462,16 +57132,55 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t aspectReferenceCount;
-    const InputAttachmentAspectReference* pAspectReferences;
+    using layout::RenderPassInputAttachmentAspectCreateInfo::sType;
   };
   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!" );
 
-  struct RenderPassMultiviewCreateInfo
+  namespace layout
+  {
+    struct RenderPassMultiviewCreateInfo
+    {
+    protected:
+      RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0,
+                                     const uint32_t* pViewMasks_ = nullptr,
+                                     uint32_t dependencyCount_ = 0,
+                                     const int32_t* pViewOffsets_ = nullptr,
+                                     uint32_t correlationMaskCount_ = 0,
+                                     const uint32_t* pCorrelationMasks_ = nullptr )
+        : subpassCount( subpassCount_ )
+        , pViewMasks( pViewMasks_ )
+        , dependencyCount( dependencyCount_ )
+        , pViewOffsets( pViewOffsets_ )
+        , correlationMaskCount( correlationMaskCount_ )
+        , pCorrelationMasks( pCorrelationMasks_ )
+      {}
+
+      RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this) = rhs;
+      }
+
+      RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo;
+      const void* pNext = nullptr;
+      uint32_t subpassCount;
+      const uint32_t* pViewMasks;
+      uint32_t dependencyCount;
+      const int32_t* pViewOffsets;
+      uint32_t correlationMaskCount;
+      const uint32_t* pCorrelationMasks;
+    };
+    static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RenderPassMultiviewCreateInfo : public layout::RenderPassMultiviewCreateInfo
   {
     RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0,
                                    const uint32_t* pViewMasks_ = nullptr,
@@ -46479,18 +57188,12 @@ namespace VULKAN_HPP_NAMESPACE
                                    const int32_t* pViewOffsets_ = nullptr,
                                    uint32_t correlationMaskCount_ = 0,
                                    const uint32_t* pCorrelationMasks_ = nullptr )
-      : subpassCount( subpassCount_ )
-      , pViewMasks( pViewMasks_ )
-      , dependencyCount( dependencyCount_ )
-      , pViewOffsets( pViewOffsets_ )
-      , correlationMaskCount( correlationMaskCount_ )
-      , pCorrelationMasks( pCorrelationMasks_ )
+      : layout::RenderPassMultiviewCreateInfo( subpassCount_, pViewMasks_, dependencyCount_, pViewOffsets_, correlationMaskCount_, pCorrelationMasks_ )
     {}
 
     RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this) = rhs;
-    }
+      : layout::RenderPassMultiviewCreateInfo( rhs )
+    {}
 
     RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs )
     {
@@ -46568,25 +57271,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassMultiviewCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t subpassCount;
-    const uint32_t* pViewMasks;
-    uint32_t dependencyCount;
-    const int32_t* pViewOffsets;
-    uint32_t correlationMaskCount;
-    const uint32_t* pCorrelationMasks;
+    using layout::RenderPassMultiviewCreateInfo::sType;
   };
   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!" );
 
   struct SubpassSampleLocationsEXT
   {
     SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0,
-                               SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : subpassIndex( subpassIndex_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
+                               vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() )
+        : subpassIndex( subpassIndex_ )
+        , sampleLocationsInfo( sampleLocationsInfo_ )
     {}
 
     SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs )
@@ -46606,7 +57301,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+    SubpassSampleLocationsEXT & setSampleLocationsInfo( vk::SampleLocationsInfoEXT sampleLocationsInfo_ )
     {
       sampleLocationsInfo = sampleLocationsInfo_;
       return *this;
@@ -46633,27 +57328,62 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t subpassIndex;
-    SampleLocationsInfoEXT sampleLocationsInfo;
+    vk::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
+  namespace layout
+  {
+    struct RenderPassSampleLocationsBeginInfoEXT
+    {
+    protected:
+      RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
+                                             const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
+                                             uint32_t postSubpassSampleLocationsCount_ = 0,
+                                             const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
+        : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
+        , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
+        , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
+        , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
+      {}
+
+      RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this) = rhs;
+      }
+
+      RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
+      const void* pNext = nullptr;
+      uint32_t attachmentInitialSampleLocationsCount;
+      const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
+      uint32_t postSubpassSampleLocationsCount;
+      const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
+    };
+    static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct RenderPassSampleLocationsBeginInfoEXT : public layout::RenderPassSampleLocationsBeginInfoEXT
   {
     RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
-                                           const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
+                                           const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
                                            uint32_t postSubpassSampleLocationsCount_ = 0,
-                                           const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
-      : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
-      , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
-      , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
-      , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
+                                           const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
+      : layout::RenderPassSampleLocationsBeginInfoEXT( attachmentInitialSampleLocationsCount_, pAttachmentInitialSampleLocations_, postSubpassSampleLocationsCount_, pPostSubpassSampleLocations_ )
     {}
 
     RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this) = rhs;
-    }
+      : layout::RenderPassSampleLocationsBeginInfoEXT( rhs )
+    {}
 
     RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
     {
@@ -46673,7 +57403,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassSampleLocationsBeginInfoEXT & setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
+    RenderPassSampleLocationsBeginInfoEXT & setPAttachmentInitialSampleLocations( const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
     {
       pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
       return *this;
@@ -46685,7 +57415,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    RenderPassSampleLocationsBeginInfoEXT & setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
+    RenderPassSampleLocationsBeginInfoEXT & setPPostSubpassSampleLocations( const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
     {
       pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
       return *this;
@@ -46717,57 +57447,108 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t attachmentInitialSampleLocationsCount;
-    const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
-    uint32_t postSubpassSampleLocationsCount;
-    const SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
+    using layout::RenderPassSampleLocationsBeginInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct SamplerCreateInfo
+    {
+    protected:
+      SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(),
+                         vk::Filter magFilter_ = vk::Filter::eNearest,
+                         vk::Filter minFilter_ = vk::Filter::eNearest,
+                         vk::SamplerMipmapMode mipmapMode_ = vk::SamplerMipmapMode::eNearest,
+                         vk::SamplerAddressMode addressModeU_ = vk::SamplerAddressMode::eRepeat,
+                         vk::SamplerAddressMode addressModeV_ = vk::SamplerAddressMode::eRepeat,
+                         vk::SamplerAddressMode addressModeW_ = vk::SamplerAddressMode::eRepeat,
+                         float mipLodBias_ = 0,
+                         vk::Bool32 anisotropyEnable_ = 0,
+                         float maxAnisotropy_ = 0,
+                         vk::Bool32 compareEnable_ = 0,
+                         vk::CompareOp compareOp_ = vk::CompareOp::eNever,
+                         float minLod_ = 0,
+                         float maxLod_ = 0,
+                         vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack,
+                         vk::Bool32 unnormalizedCoordinates_ = 0 )
+        : flags( flags_ )
+        , magFilter( magFilter_ )
+        , minFilter( minFilter_ )
+        , mipmapMode( mipmapMode_ )
+        , addressModeU( addressModeU_ )
+        , addressModeV( addressModeV_ )
+        , addressModeW( addressModeW_ )
+        , mipLodBias( mipLodBias_ )
+        , anisotropyEnable( anisotropyEnable_ )
+        , maxAnisotropy( maxAnisotropy_ )
+        , compareEnable( compareEnable_ )
+        , compareOp( compareOp_ )
+        , minLod( minLod_ )
+        , maxLod( maxLod_ )
+        , borderColor( borderColor_ )
+        , unnormalizedCoordinates( unnormalizedCoordinates_ )
+      {}
+
+      SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkSamplerCreateInfo*>(this) = rhs;
+      }
+
+      SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkSamplerCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSamplerCreateInfo;
+      const void* pNext = nullptr;
+      vk::SamplerCreateFlags flags;
+      vk::Filter magFilter;
+      vk::Filter minFilter;
+      vk::SamplerMipmapMode mipmapMode;
+      vk::SamplerAddressMode addressModeU;
+      vk::SamplerAddressMode addressModeV;
+      vk::SamplerAddressMode addressModeW;
+      float mipLodBias;
+      vk::Bool32 anisotropyEnable;
+      float maxAnisotropy;
+      vk::Bool32 compareEnable;
+      vk::CompareOp compareOp;
+      float minLod;
+      float maxLod;
+      vk::BorderColor borderColor;
+      vk::Bool32 unnormalizedCoordinates;
+    };
+    static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct SamplerCreateInfo
+  struct SamplerCreateInfo : public layout::SamplerCreateInfo
   {
-    SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(),
-                       Filter magFilter_ = Filter::eNearest,
-                       Filter minFilter_ = Filter::eNearest,
-                       SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest,
-                       SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat,
-                       SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat,
-                       SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat,
+    SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(),
+                       vk::Filter magFilter_ = vk::Filter::eNearest,
+                       vk::Filter minFilter_ = vk::Filter::eNearest,
+                       vk::SamplerMipmapMode mipmapMode_ = vk::SamplerMipmapMode::eNearest,
+                       vk::SamplerAddressMode addressModeU_ = vk::SamplerAddressMode::eRepeat,
+                       vk::SamplerAddressMode addressModeV_ = vk::SamplerAddressMode::eRepeat,
+                       vk::SamplerAddressMode addressModeW_ = vk::SamplerAddressMode::eRepeat,
                        float mipLodBias_ = 0,
-                       Bool32 anisotropyEnable_ = 0,
+                       vk::Bool32 anisotropyEnable_ = 0,
                        float maxAnisotropy_ = 0,
-                       Bool32 compareEnable_ = 0,
-                       CompareOp compareOp_ = CompareOp::eNever,
+                       vk::Bool32 compareEnable_ = 0,
+                       vk::CompareOp compareOp_ = vk::CompareOp::eNever,
                        float minLod_ = 0,
                        float maxLod_ = 0,
-                       BorderColor borderColor_ = BorderColor::eFloatTransparentBlack,
-                       Bool32 unnormalizedCoordinates_ = 0 )
-      : flags( flags_ )
-      , magFilter( magFilter_ )
-      , minFilter( minFilter_ )
-      , mipmapMode( mipmapMode_ )
-      , addressModeU( addressModeU_ )
-      , addressModeV( addressModeV_ )
-      , addressModeW( addressModeW_ )
-      , mipLodBias( mipLodBias_ )
-      , anisotropyEnable( anisotropyEnable_ )
-      , maxAnisotropy( maxAnisotropy_ )
-      , compareEnable( compareEnable_ )
-      , compareOp( compareOp_ )
-      , minLod( minLod_ )
-      , maxLod( maxLod_ )
-      , borderColor( borderColor_ )
-      , unnormalizedCoordinates( unnormalizedCoordinates_ )
+                       vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack,
+                       vk::Bool32 unnormalizedCoordinates_ = 0 )
+      : layout::SamplerCreateInfo( flags_, magFilter_, minFilter_, mipmapMode_, addressModeU_, addressModeV_, addressModeW_, mipLodBias_, anisotropyEnable_, maxAnisotropy_, compareEnable_, compareOp_, minLod_, maxLod_, borderColor_, unnormalizedCoordinates_ )
     {}
 
     SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkSamplerCreateInfo*>(this) = rhs;
-    }
+      : layout::SamplerCreateInfo( rhs )
+    {}
 
     SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
     {
@@ -46781,43 +57562,43 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SamplerCreateInfo & setFlags( SamplerCreateFlags flags_ )
+    SamplerCreateInfo & setFlags( vk::SamplerCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    SamplerCreateInfo & setMagFilter( Filter magFilter_ )
+    SamplerCreateInfo & setMagFilter( vk::Filter magFilter_ )
     {
       magFilter = magFilter_;
       return *this;
     }
 
-    SamplerCreateInfo & setMinFilter( Filter minFilter_ )
+    SamplerCreateInfo & setMinFilter( vk::Filter minFilter_ )
     {
       minFilter = minFilter_;
       return *this;
     }
 
-    SamplerCreateInfo & setMipmapMode( SamplerMipmapMode mipmapMode_ )
+    SamplerCreateInfo & setMipmapMode( vk::SamplerMipmapMode mipmapMode_ )
     {
       mipmapMode = mipmapMode_;
       return *this;
     }
 
-    SamplerCreateInfo & setAddressModeU( SamplerAddressMode addressModeU_ )
+    SamplerCreateInfo & setAddressModeU( vk::SamplerAddressMode addressModeU_ )
     {
       addressModeU = addressModeU_;
       return *this;
     }
 
-    SamplerCreateInfo & setAddressModeV( SamplerAddressMode addressModeV_ )
+    SamplerCreateInfo & setAddressModeV( vk::SamplerAddressMode addressModeV_ )
     {
       addressModeV = addressModeV_;
       return *this;
     }
 
-    SamplerCreateInfo & setAddressModeW( SamplerAddressMode addressModeW_ )
+    SamplerCreateInfo & setAddressModeW( vk::SamplerAddressMode addressModeW_ )
     {
       addressModeW = addressModeW_;
       return *this;
@@ -46829,7 +57610,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SamplerCreateInfo & setAnisotropyEnable( Bool32 anisotropyEnable_ )
+    SamplerCreateInfo & setAnisotropyEnable( vk::Bool32 anisotropyEnable_ )
     {
       anisotropyEnable = anisotropyEnable_;
       return *this;
@@ -46841,13 +57622,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SamplerCreateInfo & setCompareEnable( Bool32 compareEnable_ )
+    SamplerCreateInfo & setCompareEnable( vk::Bool32 compareEnable_ )
     {
       compareEnable = compareEnable_;
       return *this;
     }
 
-    SamplerCreateInfo & setCompareOp( CompareOp compareOp_ )
+    SamplerCreateInfo & setCompareOp( vk::CompareOp compareOp_ )
     {
       compareOp = compareOp_;
       return *this;
@@ -46865,13 +57646,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SamplerCreateInfo & setBorderColor( BorderColor borderColor_ )
+    SamplerCreateInfo & setBorderColor( vk::BorderColor borderColor_ )
     {
       borderColor = borderColor_;
       return *this;
     }
 
-    SamplerCreateInfo & setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ )
+    SamplerCreateInfo & setUnnormalizedCoordinates( vk::Bool32 unnormalizedCoordinates_ )
     {
       unnormalizedCoordinates = unnormalizedCoordinates_;
       return *this;
@@ -46915,39 +57696,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSamplerCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    SamplerCreateFlags flags;
-    Filter magFilter;
-    Filter minFilter;
-    SamplerMipmapMode mipmapMode;
-    SamplerAddressMode addressModeU;
-    SamplerAddressMode addressModeV;
-    SamplerAddressMode addressModeW;
-    float mipLodBias;
-    Bool32 anisotropyEnable;
-    float maxAnisotropy;
-    Bool32 compareEnable;
-    CompareOp compareOp;
-    float minLod;
-    float maxLod;
-    BorderColor borderColor;
-    Bool32 unnormalizedCoordinates;
+    using layout::SamplerCreateInfo::sType;
   };
   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!" );
 
-  struct SamplerReductionModeCreateInfoEXT
+  namespace layout
   {
-    SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage )
-      : reductionMode( reductionMode_ )
+    struct SamplerReductionModeCreateInfoEXT
+    {
+    protected:
+      SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage )
+        : reductionMode( reductionMode_ )
+      {}
+
+      SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this) = rhs;
+      }
+
+      SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::SamplerReductionModeEXT reductionMode;
+    };
+    static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SamplerReductionModeCreateInfoEXT : public layout::SamplerReductionModeCreateInfoEXT
+  {
+    SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage )
+      : layout::SamplerReductionModeCreateInfoEXT( reductionMode_ )
     {}
 
     SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::SamplerReductionModeCreateInfoEXT( rhs )
+    {}
 
     SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs )
     {
@@ -46961,7 +57751,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SamplerReductionModeCreateInfoEXT & setReductionMode( SamplerReductionModeEXT reductionMode_ )
+    SamplerReductionModeCreateInfoEXT & setReductionMode( vk::SamplerReductionModeEXT reductionMode_ )
     {
       reductionMode = reductionMode_;
       return *this;
@@ -46990,38 +57780,76 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    SamplerReductionModeEXT reductionMode;
+    using layout::SamplerReductionModeCreateInfoEXT::sType;
   };
   static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<SamplerReductionModeCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct SamplerYcbcrConversionCreateInfo
+    {
+    protected:
+      SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined,
+                                        vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity,
+                                        vk::SamplerYcbcrRange ycbcrRange_ = vk::SamplerYcbcrRange::eItuFull,
+                                        vk::ComponentMapping components_ = vk::ComponentMapping(),
+                                        vk::ChromaLocation xChromaOffset_ = vk::ChromaLocation::eCositedEven,
+                                        vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven,
+                                        vk::Filter chromaFilter_ = vk::Filter::eNearest,
+                                        vk::Bool32 forceExplicitReconstruction_ = 0 )
+        : format( format_ )
+        , ycbcrModel( ycbcrModel_ )
+        , ycbcrRange( ycbcrRange_ )
+        , components( components_ )
+        , xChromaOffset( xChromaOffset_ )
+        , yChromaOffset( yChromaOffset_ )
+        , chromaFilter( chromaFilter_ )
+        , forceExplicitReconstruction( forceExplicitReconstruction_ )
+      {}
 
-  struct SamplerYcbcrConversionCreateInfo
-  {
-    SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined,
-                                      SamplerYcbcrModelConversion ycbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity,
-                                      SamplerYcbcrRange ycbcrRange_ = SamplerYcbcrRange::eItuFull,
-                                      ComponentMapping components_ = ComponentMapping(),
-                                      ChromaLocation xChromaOffset_ = ChromaLocation::eCositedEven,
-                                      ChromaLocation yChromaOffset_ = ChromaLocation::eCositedEven,
-                                      Filter chromaFilter_ = Filter::eNearest,
-                                      Bool32 forceExplicitReconstruction_ = 0 )
-      : format( format_ )
-      , ycbcrModel( ycbcrModel_ )
-      , ycbcrRange( ycbcrRange_ )
-      , components( components_ )
-      , xChromaOffset( xChromaOffset_ )
-      , yChromaOffset( yChromaOffset_ )
-      , chromaFilter( chromaFilter_ )
-      , forceExplicitReconstruction( forceExplicitReconstruction_ )
+      SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this) = rhs;
+      }
+
+      SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo;
+      const void* pNext = nullptr;
+      vk::Format format;
+      vk::SamplerYcbcrModelConversion ycbcrModel;
+      vk::SamplerYcbcrRange ycbcrRange;
+      vk::ComponentMapping components;
+      vk::ChromaLocation xChromaOffset;
+      vk::ChromaLocation yChromaOffset;
+      vk::Filter chromaFilter;
+      vk::Bool32 forceExplicitReconstruction;
+    };
+    static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SamplerYcbcrConversionCreateInfo : public layout::SamplerYcbcrConversionCreateInfo
+  {
+    SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined,
+                                      vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity,
+                                      vk::SamplerYcbcrRange ycbcrRange_ = vk::SamplerYcbcrRange::eItuFull,
+                                      vk::ComponentMapping components_ = vk::ComponentMapping(),
+                                      vk::ChromaLocation xChromaOffset_ = vk::ChromaLocation::eCositedEven,
+                                      vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven,
+                                      vk::Filter chromaFilter_ = vk::Filter::eNearest,
+                                      vk::Bool32 forceExplicitReconstruction_ = 0 )
+      : layout::SamplerYcbcrConversionCreateInfo( format_, ycbcrModel_, ycbcrRange_, components_, xChromaOffset_, yChromaOffset_, chromaFilter_, forceExplicitReconstruction_ )
     {}
 
     SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this) = rhs;
-    }
+      : layout::SamplerYcbcrConversionCreateInfo( rhs )
+    {}
 
     SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs )
     {
@@ -47035,49 +57863,49 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setFormat( Format format_ )
+    SamplerYcbcrConversionCreateInfo & setFormat( vk::Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ )
+    SamplerYcbcrConversionCreateInfo & setYcbcrModel( vk::SamplerYcbcrModelConversion ycbcrModel_ )
     {
       ycbcrModel = ycbcrModel_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setYcbcrRange( SamplerYcbcrRange ycbcrRange_ )
+    SamplerYcbcrConversionCreateInfo & setYcbcrRange( vk::SamplerYcbcrRange ycbcrRange_ )
     {
       ycbcrRange = ycbcrRange_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setComponents( ComponentMapping components_ )
+    SamplerYcbcrConversionCreateInfo & setComponents( vk::ComponentMapping components_ )
     {
       components = components_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setXChromaOffset( ChromaLocation xChromaOffset_ )
+    SamplerYcbcrConversionCreateInfo & setXChromaOffset( vk::ChromaLocation xChromaOffset_ )
     {
       xChromaOffset = xChromaOffset_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setYChromaOffset( ChromaLocation yChromaOffset_ )
+    SamplerYcbcrConversionCreateInfo & setYChromaOffset( vk::ChromaLocation yChromaOffset_ )
     {
       yChromaOffset = yChromaOffset_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setChromaFilter( Filter chromaFilter_ )
+    SamplerYcbcrConversionCreateInfo & setChromaFilter( vk::Filter chromaFilter_ )
     {
       chromaFilter = chromaFilter_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo & setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ )
+    SamplerYcbcrConversionCreateInfo & setForceExplicitReconstruction( vk::Bool32 forceExplicitReconstruction_ )
     {
       forceExplicitReconstruction = forceExplicitReconstruction_;
       return *this;
@@ -47113,22 +57941,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Format format;
-    SamplerYcbcrModelConversion ycbcrModel;
-    SamplerYcbcrRange ycbcrRange;
-    ComponentMapping components;
-    ChromaLocation xChromaOffset;
-    ChromaLocation yChromaOffset;
-    Filter chromaFilter;
-    Bool32 forceExplicitReconstruction;
+    using layout::SamplerYcbcrConversionCreateInfo::sType;
   };
   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!" );
 
-  struct SamplerYcbcrConversionImageFormatProperties
+  namespace layout
+  {
+    struct SamplerYcbcrConversionImageFormatProperties
+    {
+    protected:
+      SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = 0 )
+        : combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ )
+      {}
+
+      SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs )
+      {
+        *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this) = rhs;
+      }
+
+      SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs )
+      {
+        *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
+      void* pNext = nullptr;
+      uint32_t combinedImageSamplerDescriptorCount;
+    };
+    static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SamplerYcbcrConversionImageFormatProperties : public layout::SamplerYcbcrConversionImageFormatProperties
   {
     operator VkSamplerYcbcrConversionImageFormatProperties const&() const
     {
@@ -47153,24 +57999,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t combinedImageSamplerDescriptorCount;
+    using layout::SamplerYcbcrConversionImageFormatProperties::sType;
   };
   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!" );
 
-  struct SamplerYcbcrConversionInfo
+  namespace layout
   {
-    SamplerYcbcrConversionInfo( SamplerYcbcrConversion conversion_ = SamplerYcbcrConversion() )
-      : conversion( conversion_ )
+    struct SamplerYcbcrConversionInfo
+    {
+    protected:
+      SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() )
+        : conversion( conversion_ )
+      {}
+
+      SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs )
+      {
+        *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this) = rhs;
+      }
+
+      SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs )
+      {
+        *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSamplerYcbcrConversionInfo;
+      const void* pNext = nullptr;
+      vk::SamplerYcbcrConversion conversion;
+    };
+    static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SamplerYcbcrConversionInfo : public layout::SamplerYcbcrConversionInfo
+  {
+    SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() )
+      : layout::SamplerYcbcrConversionInfo( conversion_ )
     {}
 
     SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs )
-    {
-      *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this) = rhs;
-    }
+      : layout::SamplerYcbcrConversionInfo( rhs )
+    {}
 
     SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs )
     {
@@ -47184,7 +58054,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SamplerYcbcrConversionInfo & setConversion( SamplerYcbcrConversion conversion_ )
+    SamplerYcbcrConversionInfo & setConversion( vk::SamplerYcbcrConversion conversion_ )
     {
       conversion = conversion_;
       return *this;
@@ -47213,24 +58083,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSamplerYcbcrConversionInfo;
-
-  public:
-    const void* pNext = nullptr;
-    SamplerYcbcrConversion conversion;
+    using layout::SamplerYcbcrConversionInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct SemaphoreCreateInfo
+    {
+    protected:
+      SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() )
+        : flags( flags_ )
+      {}
+
+      SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkSemaphoreCreateInfo*>(this) = rhs;
+      }
+
+      SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkSemaphoreCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSemaphoreCreateInfo;
+      const void* pNext = nullptr;
+      vk::SemaphoreCreateFlags flags;
+    };
+    static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "layout struct and wrapper have different size!" );
+  }
 
-  struct SemaphoreCreateInfo
+  struct SemaphoreCreateInfo : public layout::SemaphoreCreateInfo
   {
-    SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() )
-      : flags( flags_ )
+    SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() )
+      : layout::SemaphoreCreateInfo( flags_ )
     {}
 
     SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkSemaphoreCreateInfo*>(this) = rhs;
-    }
+      : layout::SemaphoreCreateInfo( rhs )
+    {}
 
     SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
     {
@@ -47244,7 +58138,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SemaphoreCreateInfo & setFlags( SemaphoreCreateFlags flags_ )
+    SemaphoreCreateInfo & setFlags( vk::SemaphoreCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -47273,26 +58167,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSemaphoreCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    SemaphoreCreateFlags flags;
+    using layout::SemaphoreCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct SemaphoreGetFdInfoKHR
+    {
+    protected:
+      SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+                             vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+        : semaphore( semaphore_ )
+        , handleType( handleType_ )
+      {}
+
+      SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this) = rhs;
+      }
 
-  struct SemaphoreGetFdInfoKHR
+      SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
+      const void* pNext = nullptr;
+      vk::Semaphore semaphore;
+      vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SemaphoreGetFdInfoKHR : public layout::SemaphoreGetFdInfoKHR
   {
-    SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(),
-                           ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
-      : semaphore( semaphore_ )
-      , handleType( handleType_ )
+    SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+                           vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+      : layout::SemaphoreGetFdInfoKHR( semaphore_, handleType_ )
     {}
 
     SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this) = rhs;
-    }
+      : layout::SemaphoreGetFdInfoKHR( rhs )
+    {}
 
     SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
     {
@@ -47306,13 +58226,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SemaphoreGetFdInfoKHR & setSemaphore( Semaphore semaphore_ )
+    SemaphoreGetFdInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
     {
       semaphore = semaphore_;
       return *this;
     }
 
-    SemaphoreGetFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    SemaphoreGetFdInfoKHR & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -47342,28 +58262,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
+    using layout::SemaphoreGetFdInfoKHR::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct SemaphoreGetWin32HandleInfoKHR
+
+  namespace layout
+  {
+    struct SemaphoreGetWin32HandleInfoKHR
+    {
+    protected:
+      SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+                                      vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+        : semaphore( semaphore_ )
+        , handleType( handleType_ )
+      {}
+
+      SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this) = rhs;
+      }
+
+      SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
+      const void* pNext = nullptr;
+      vk::Semaphore semaphore;
+      vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+    };
+    static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SemaphoreGetWin32HandleInfoKHR : public layout::SemaphoreGetWin32HandleInfoKHR
   {
-    SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
-                                    ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
-      : semaphore( semaphore_ )
-      , handleType( handleType_ )
+    SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+                                    vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+      : layout::SemaphoreGetWin32HandleInfoKHR( semaphore_, handleType_ )
     {}
 
     SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this) = rhs;
-    }
+      : layout::SemaphoreGetWin32HandleInfoKHR( rhs )
+    {}
 
     SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
     {
@@ -47377,13 +58323,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SemaphoreGetWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ )
+    SemaphoreGetWin32HandleInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
     {
       semaphore = semaphore_;
       return *this;
     }
 
-    SemaphoreGetWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    SemaphoreGetWin32HandleInfoKHR & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
     {
       handleType = handleType_;
       return *this;
@@ -47413,30 +58359,57 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
+    using layout::SemaphoreGetWin32HandleInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct ShaderModuleCreateInfo
+  namespace layout
   {
-    ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(),
+    struct ShaderModuleCreateInfo
+    {
+    protected:
+      ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(),
+                              size_t codeSize_ = 0,
+                              const uint32_t* pCode_ = nullptr )
+        : flags( flags_ )
+        , codeSize( codeSize_ )
+        , pCode( pCode_ )
+      {}
+
+      ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkShaderModuleCreateInfo*>(this) = rhs;
+      }
+
+      ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
+      {
+        *reinterpret_cast<VkShaderModuleCreateInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eShaderModuleCreateInfo;
+      const void* pNext = nullptr;
+      vk::ShaderModuleCreateFlags flags;
+      size_t codeSize;
+      const uint32_t* pCode;
+    };
+    static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ShaderModuleCreateInfo : public layout::ShaderModuleCreateInfo
+  {
+    ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(),
                             size_t codeSize_ = 0,
                             const uint32_t* pCode_ = nullptr )
-      : flags( flags_ )
-      , codeSize( codeSize_ )
-      , pCode( pCode_ )
+      : layout::ShaderModuleCreateInfo( flags_, codeSize_, pCode_ )
     {}
 
     ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
-    {
-      *reinterpret_cast<VkShaderModuleCreateInfo*>(this) = rhs;
-    }
+      : layout::ShaderModuleCreateInfo( rhs )
+    {}
 
     ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
     {
@@ -47450,7 +58423,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ShaderModuleCreateInfo & setFlags( ShaderModuleCreateFlags flags_ )
+    ShaderModuleCreateInfo & setFlags( vk::ShaderModuleCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -47493,26 +58466,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eShaderModuleCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ShaderModuleCreateFlags flags;
-    size_t codeSize;
-    const uint32_t* pCode;
+    using layout::ShaderModuleCreateInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ShaderModuleValidationCacheCreateInfoEXT
+    {
+    protected:
+      ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() )
+        : validationCache( validationCache_ )
+      {}
+
+      ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this) = rhs;
+      }
+
+      ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::ValidationCacheEXT validationCache;
+    };
+    static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ShaderModuleValidationCacheCreateInfoEXT
+  struct ShaderModuleValidationCacheCreateInfoEXT : public layout::ShaderModuleValidationCacheCreateInfoEXT
   {
-    ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() )
-      : validationCache( validationCache_ )
+    ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() )
+      : layout::ShaderModuleValidationCacheCreateInfoEXT( validationCache_ )
     {}
 
     ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::ShaderModuleValidationCacheCreateInfoEXT( rhs )
+    {}
 
     ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
     {
@@ -47526,7 +58521,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ShaderModuleValidationCacheCreateInfoEXT & setValidationCache( ValidationCacheEXT validationCache_ )
+    ShaderModuleValidationCacheCreateInfoEXT & setValidationCache( vk::ValidationCacheEXT validationCache_ )
     {
       validationCache = validationCache_;
       return *this;
@@ -47555,13 +58550,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ValidationCacheEXT validationCache;
+    using layout::ShaderModuleValidationCacheCreateInfoEXT::sType;
   };
   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!" );
 
   struct ShaderResourceUsageAMD
   {
@@ -47589,6 +58581,7 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t numUsedVgprs;
     uint32_t numUsedSgprs;
     uint32_t ldsSizePerLocalWorkGroup;
@@ -47596,6 +58589,7 @@ namespace VULKAN_HPP_NAMESPACE
     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
   {
@@ -47625,8 +58619,9 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ShaderStageFlags shaderStageMask;
-    ShaderResourceUsageAMD resourceUsage;
+  public:
+    vk::ShaderStageFlags shaderStageMask;
+    vk::ShaderResourceUsageAMD resourceUsage;
     uint32_t numPhysicalVgprs;
     uint32_t numPhysicalSgprs;
     uint32_t numAvailableVgprs;
@@ -47634,8 +58629,37 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t computeWorkGroupSize[3];
   };
   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!" );
+
+  namespace layout
+  {
+    struct SharedPresentSurfaceCapabilitiesKHR
+    {
+    protected:
+      SharedPresentSurfaceCapabilitiesKHR( vk::ImageUsageFlags sharedPresentSupportedUsageFlags_ = vk::ImageUsageFlags() )
+        : sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ )
+      {}
+
+      SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this) = rhs;
+      }
+
+      SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
+      void* pNext = nullptr;
+      vk::ImageUsageFlags sharedPresentSupportedUsageFlags;
+    };
+    static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct SharedPresentSurfaceCapabilitiesKHR
+  struct SharedPresentSurfaceCapabilitiesKHR : public layout::SharedPresentSurfaceCapabilitiesKHR
   {
     operator VkSharedPresentSurfaceCapabilitiesKHR const&() const
     {
@@ -47660,13 +58684,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    ImageUsageFlags sharedPresentSupportedUsageFlags;
+    using layout::SharedPresentSurfaceCapabilitiesKHR::sType;
   };
   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!" );
 
   struct SparseImageFormatProperties
   {
@@ -47692,13 +58713,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    ImageAspectFlags aspectMask;
-    Extent3D imageGranularity;
-    SparseImageFormatFlags flags;
+  public:
+    vk::ImageAspectFlags aspectMask;
+    vk::Extent3D imageGranularity;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct SparseImageFormatProperties2
+    {
+    protected:
+      SparseImageFormatProperties2( vk::SparseImageFormatProperties properties_ = vk::SparseImageFormatProperties() )
+        : properties( properties_ )
+      {}
 
-  struct SparseImageFormatProperties2
+      SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkSparseImageFormatProperties2*>(this) = rhs;
+      }
+
+      SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs )
+      {
+        *reinterpret_cast<VkSparseImageFormatProperties2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSparseImageFormatProperties2;
+      void* pNext = nullptr;
+      vk::SparseImageFormatProperties properties;
+    };
+    static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SparseImageFormatProperties2 : public layout::SparseImageFormatProperties2
   {
     operator VkSparseImageFormatProperties2 const&() const
     {
@@ -47723,13 +58774,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSparseImageFormatProperties2;
-
-  public:
-    void* pNext = nullptr;
-    SparseImageFormatProperties properties;
+    using layout::SparseImageFormatProperties2::sType;
   };
   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!" );
 
   struct SparseImageMemoryRequirements
   {
@@ -47757,15 +58805,45 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    SparseImageFormatProperties formatProperties;
+  public:
+    vk::SparseImageFormatProperties formatProperties;
     uint32_t imageMipTailFirstLod;
-    DeviceSize imageMipTailSize;
-    DeviceSize imageMipTailOffset;
-    DeviceSize imageMipTailStride;
+    vk::DeviceSize imageMipTailSize;
+    vk::DeviceSize imageMipTailOffset;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct SparseImageMemoryRequirements2
+    {
+    protected:
+      SparseImageMemoryRequirements2( vk::SparseImageMemoryRequirements memoryRequirements_ = vk::SparseImageMemoryRequirements() )
+        : memoryRequirements( memoryRequirements_ )
+      {}
 
-  struct SparseImageMemoryRequirements2
+      SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs )
+      {
+        *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this) = rhs;
+      }
+
+      SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs )
+      {
+        *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSparseImageMemoryRequirements2;
+      void* pNext = nullptr;
+      vk::SparseImageMemoryRequirements memoryRequirements;
+    };
+    static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SparseImageMemoryRequirements2 : public layout::SparseImageMemoryRequirements2
   {
     operator VkSparseImageMemoryRequirements2 const&() const
     {
@@ -47790,27 +58868,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSparseImageMemoryRequirements2;
-
-  public:
-    void* pNext = nullptr;
-    SparseImageMemoryRequirements memoryRequirements;
+    using layout::SparseImageMemoryRequirements2::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_GGP
-  struct StreamDescriptorSurfaceCreateInfoGGP
+
+  namespace layout
+  {
+    struct StreamDescriptorSurfaceCreateInfoGGP
+    {
+    protected:
+      StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(),
+                                            GgpStreamDescriptor streamDescriptor_ = 0 )
+        : flags( flags_ )
+        , streamDescriptor( streamDescriptor_ )
+      {}
+
+      StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs )
+      {
+        *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(this) = rhs;
+      }
+
+      StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs )
+      {
+        *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP;
+      const void* pNext = nullptr;
+      vk::StreamDescriptorSurfaceCreateFlagsGGP flags;
+      GgpStreamDescriptor streamDescriptor;
+    };
+    static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "layout struct and wrapper have different size!" );
+  }
+
+  struct StreamDescriptorSurfaceCreateInfoGGP : public layout::StreamDescriptorSurfaceCreateInfoGGP
   {
-    StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateFlagsGGP flags_ = StreamDescriptorSurfaceCreateFlagsGGP(),
+    StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(),
                                           GgpStreamDescriptor streamDescriptor_ = 0 )
-      : flags( flags_ )
-      , streamDescriptor( streamDescriptor_ )
+      : layout::StreamDescriptorSurfaceCreateInfoGGP( flags_, streamDescriptor_ )
     {}
 
     StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs )
-    {
-      *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(this) = rhs;
-    }
+      : layout::StreamDescriptorSurfaceCreateInfoGGP( rhs )
+    {}
 
     StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs )
     {
@@ -47824,7 +58929,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    StreamDescriptorSurfaceCreateInfoGGP & setFlags( StreamDescriptorSurfaceCreateFlagsGGP flags_ )
+    StreamDescriptorSurfaceCreateInfoGGP & setFlags( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ )
     {
       flags = flags_;
       return *this;
@@ -47860,38 +58965,73 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP;
-
-  public:
-    const void* pNext = nullptr;
-    StreamDescriptorSurfaceCreateFlagsGGP flags;
-    GgpStreamDescriptor streamDescriptor;
+    using layout::StreamDescriptorSurfaceCreateInfoGGP::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_GGP*/
 
-  struct SubmitInfo
+  namespace layout
+  {
+    struct SubmitInfo
+    {
+    protected:
+      SubmitInfo( uint32_t waitSemaphoreCount_ = 0,
+                  const vk::Semaphore* pWaitSemaphores_ = nullptr,
+                  const vk::PipelineStageFlags* pWaitDstStageMask_ = nullptr,
+                  uint32_t commandBufferCount_ = 0,
+                  const vk::CommandBuffer* pCommandBuffers_ = nullptr,
+                  uint32_t signalSemaphoreCount_ = 0,
+                  const vk::Semaphore* pSignalSemaphores_ = nullptr )
+        : waitSemaphoreCount( waitSemaphoreCount_ )
+        , pWaitSemaphores( pWaitSemaphores_ )
+        , pWaitDstStageMask( pWaitDstStageMask_ )
+        , commandBufferCount( commandBufferCount_ )
+        , pCommandBuffers( pCommandBuffers_ )
+        , signalSemaphoreCount( signalSemaphoreCount_ )
+        , pSignalSemaphores( pSignalSemaphores_ )
+      {}
+
+      SubmitInfo( VkSubmitInfo const & rhs )
+      {
+        *reinterpret_cast<VkSubmitInfo*>(this) = rhs;
+      }
+
+      SubmitInfo& operator=( VkSubmitInfo const & rhs )
+      {
+        *reinterpret_cast<VkSubmitInfo*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSubmitInfo;
+      const void* pNext = nullptr;
+      uint32_t waitSemaphoreCount;
+      const vk::Semaphore* pWaitSemaphores;
+      const vk::PipelineStageFlags* pWaitDstStageMask;
+      uint32_t commandBufferCount;
+      const vk::CommandBuffer* pCommandBuffers;
+      uint32_t signalSemaphoreCount;
+      const vk::Semaphore* pSignalSemaphores;
+    };
+    static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SubmitInfo : public layout::SubmitInfo
   {
     SubmitInfo( uint32_t waitSemaphoreCount_ = 0,
-                const Semaphore* pWaitSemaphores_ = nullptr,
-                const PipelineStageFlags* pWaitDstStageMask_ = nullptr,
+                const vk::Semaphore* pWaitSemaphores_ = nullptr,
+                const vk::PipelineStageFlags* pWaitDstStageMask_ = nullptr,
                 uint32_t commandBufferCount_ = 0,
-                const CommandBuffer* pCommandBuffers_ = nullptr,
+                const vk::CommandBuffer* pCommandBuffers_ = nullptr,
                 uint32_t signalSemaphoreCount_ = 0,
-                const Semaphore* pSignalSemaphores_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , pWaitDstStageMask( pWaitDstStageMask_ )
-      , commandBufferCount( commandBufferCount_ )
-      , pCommandBuffers( pCommandBuffers_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphores( pSignalSemaphores_ )
+                const vk::Semaphore* pSignalSemaphores_ = nullptr )
+      : layout::SubmitInfo( waitSemaphoreCount_, pWaitSemaphores_, pWaitDstStageMask_, commandBufferCount_, pCommandBuffers_, signalSemaphoreCount_, pSignalSemaphores_ )
     {}
 
     SubmitInfo( VkSubmitInfo const & rhs )
-    {
-      *reinterpret_cast<VkSubmitInfo*>(this) = rhs;
-    }
+      : layout::SubmitInfo( rhs )
+    {}
 
     SubmitInfo& operator=( VkSubmitInfo const & rhs )
     {
@@ -47911,13 +59051,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubmitInfo & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+    SubmitInfo & setPWaitSemaphores( const vk::Semaphore* pWaitSemaphores_ )
     {
       pWaitSemaphores = pWaitSemaphores_;
       return *this;
     }
 
-    SubmitInfo & setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ )
+    SubmitInfo & setPWaitDstStageMask( const vk::PipelineStageFlags* pWaitDstStageMask_ )
     {
       pWaitDstStageMask = pWaitDstStageMask_;
       return *this;
@@ -47929,7 +59069,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubmitInfo & setPCommandBuffers( const CommandBuffer* pCommandBuffers_ )
+    SubmitInfo & setPCommandBuffers( const vk::CommandBuffer* pCommandBuffers_ )
     {
       pCommandBuffers = pCommandBuffers_;
       return *this;
@@ -47941,7 +59081,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubmitInfo & setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+    SubmitInfo & setPSignalSemaphores( const vk::Semaphore* pSignalSemaphores_ )
     {
       pSignalSemaphores = pSignalSemaphores_;
       return *this;
@@ -47976,30 +59116,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSubmitInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    const PipelineStageFlags* pWaitDstStageMask;
-    uint32_t commandBufferCount;
-    const CommandBuffer* pCommandBuffers;
-    uint32_t signalSemaphoreCount;
-    const Semaphore* pSignalSemaphores;
+    using layout::SubmitInfo::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct SubpassBeginInfoKHR
+    {
+    protected:
+      SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline )
+        : contents( contents_ )
+      {}
+
+      SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassBeginInfoKHR*>(this) = rhs;
+      }
+
+      SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassBeginInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSubpassBeginInfoKHR;
+      const void* pNext = nullptr;
+      vk::SubpassContents contents;
+    };
+    static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "layout struct and wrapper have different size!" );
+  }
 
-  struct SubpassBeginInfoKHR
+  struct SubpassBeginInfoKHR : public layout::SubpassBeginInfoKHR
   {
-    SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline )
-      : contents( contents_ )
+    SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline )
+      : layout::SubpassBeginInfoKHR( contents_ )
     {}
 
     SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkSubpassBeginInfoKHR*>(this) = rhs;
-    }
+      : layout::SubpassBeginInfoKHR( rhs )
+    {}
 
     SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
     {
@@ -48013,7 +59171,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassBeginInfoKHR & setContents( SubpassContents contents_ )
+    SubpassBeginInfoKHR & setContents( vk::SubpassContents contents_ )
     {
       contents = contents_;
       return *this;
@@ -48042,28 +59200,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSubpassBeginInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SubpassContents contents;
+    using layout::SubpassBeginInfoKHR::sType;
   };
   static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<SubpassBeginInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct SubpassDescriptionDepthStencilResolveKHR
+    {
+    protected:
+      SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
+                                                vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
+                                                const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr )
+        : depthResolveMode( depthResolveMode_ )
+        , stencilResolveMode( stencilResolveMode_ )
+        , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
+      {}
+
+      SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR*>(this) = rhs;
+      }
 
-  struct SubpassDescriptionDepthStencilResolveKHR
+      SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR;
+      const void* pNext = nullptr;
+      vk::ResolveModeFlagBitsKHR depthResolveMode;
+      vk::ResolveModeFlagBitsKHR stencilResolveMode;
+      const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment;
+    };
+    static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SubpassDescriptionDepthStencilResolveKHR : public layout::SubpassDescriptionDepthStencilResolveKHR
   {
-    SubpassDescriptionDepthStencilResolveKHR( ResolveModeFlagBitsKHR depthResolveMode_ = ResolveModeFlagBitsKHR::eNone,
-                                              ResolveModeFlagBitsKHR stencilResolveMode_ = ResolveModeFlagBitsKHR::eNone,
-                                              const AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr )
-      : depthResolveMode( depthResolveMode_ )
-      , stencilResolveMode( stencilResolveMode_ )
-      , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
+    SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
+                                              vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
+                                              const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr )
+      : layout::SubpassDescriptionDepthStencilResolveKHR( depthResolveMode_, stencilResolveMode_, pDepthStencilResolveAttachment_ )
     {}
 
     SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
-    {
-      *reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR*>(this) = rhs;
-    }
+      : layout::SubpassDescriptionDepthStencilResolveKHR( rhs )
+    {}
 
     SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
     {
@@ -48077,19 +59263,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SubpassDescriptionDepthStencilResolveKHR & setDepthResolveMode( ResolveModeFlagBitsKHR depthResolveMode_ )
+    SubpassDescriptionDepthStencilResolveKHR & setDepthResolveMode( vk::ResolveModeFlagBitsKHR depthResolveMode_ )
     {
       depthResolveMode = depthResolveMode_;
       return *this;
     }
 
-    SubpassDescriptionDepthStencilResolveKHR & setStencilResolveMode( ResolveModeFlagBitsKHR stencilResolveMode_ )
+    SubpassDescriptionDepthStencilResolveKHR & setStencilResolveMode( vk::ResolveModeFlagBitsKHR stencilResolveMode_ )
     {
       stencilResolveMode = stencilResolveMode_;
       return *this;
     }
 
-    SubpassDescriptionDepthStencilResolveKHR & setPDepthStencilResolveAttachment( const AttachmentReference2KHR* pDepthStencilResolveAttachment_ )
+    SubpassDescriptionDepthStencilResolveKHR & setPDepthStencilResolveAttachment( const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ )
     {
       pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_;
       return *this;
@@ -48120,25 +59306,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ResolveModeFlagBitsKHR depthResolveMode;
-    ResolveModeFlagBitsKHR stencilResolveMode;
-    const AttachmentReference2KHR* pDepthStencilResolveAttachment;
+    using layout::SubpassDescriptionDepthStencilResolveKHR::sType;
   };
   static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<SubpassDescriptionDepthStencilResolveKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct SubpassEndInfoKHR
+    {
+    protected:
+      SubpassEndInfoKHR()
 
-  struct SubpassEndInfoKHR
+      {}
+
+      SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassEndInfoKHR*>(this) = rhs;
+      }
+
+      SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSubpassEndInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSubpassEndInfoKHR;
+      const void* pNext = nullptr;
+    };
+    static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SubpassEndInfoKHR : public layout::SubpassEndInfoKHR
   {
-    SubpassEndInfoKHR(  )
+    SubpassEndInfoKHR()
+
+      : layout::SubpassEndInfoKHR(  )
     {}
 
     SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkSubpassEndInfoKHR*>(this) = rhs;
-    }
+      : layout::SubpassEndInfoKHR( rhs )
+    {}
 
     SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs )
     {
@@ -48174,14 +59383,70 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSubpassEndInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
+    using layout::SubpassEndInfoKHR::sType;
   };
   static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<SubpassEndInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct SurfaceCapabilities2EXT
+    {
+    protected:
+      SurfaceCapabilities2EXT( uint32_t minImageCount_ = 0,
+                               uint32_t maxImageCount_ = 0,
+                               vk::Extent2D currentExtent_ = vk::Extent2D(),
+                               vk::Extent2D minImageExtent_ = vk::Extent2D(),
+                               vk::Extent2D maxImageExtent_ = vk::Extent2D(),
+                               uint32_t maxImageArrayLayers_ = 0,
+                               vk::SurfaceTransformFlagsKHR supportedTransforms_ = vk::SurfaceTransformFlagsKHR(),
+                               vk::SurfaceTransformFlagBitsKHR currentTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
+                               vk::CompositeAlphaFlagsKHR supportedCompositeAlpha_ = vk::CompositeAlphaFlagsKHR(),
+                               vk::ImageUsageFlags supportedUsageFlags_ = vk::ImageUsageFlags(),
+                               vk::SurfaceCounterFlagsEXT supportedSurfaceCounters_ = vk::SurfaceCounterFlagsEXT() )
+        : minImageCount( minImageCount_ )
+        , maxImageCount( maxImageCount_ )
+        , currentExtent( currentExtent_ )
+        , minImageExtent( minImageExtent_ )
+        , maxImageExtent( maxImageExtent_ )
+        , maxImageArrayLayers( maxImageArrayLayers_ )
+        , supportedTransforms( supportedTransforms_ )
+        , currentTransform( currentTransform_ )
+        , supportedCompositeAlpha( supportedCompositeAlpha_ )
+        , supportedUsageFlags( supportedUsageFlags_ )
+        , supportedSurfaceCounters( supportedSurfaceCounters_ )
+      {}
+
+      SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this) = rhs;
+      }
+
+      SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSurfaceCapabilities2EXT;
+      void* pNext = nullptr;
+      uint32_t minImageCount;
+      uint32_t maxImageCount;
+      vk::Extent2D currentExtent;
+      vk::Extent2D minImageExtent;
+      vk::Extent2D maxImageExtent;
+      uint32_t maxImageArrayLayers;
+      vk::SurfaceTransformFlagsKHR supportedTransforms;
+      vk::SurfaceTransformFlagBitsKHR currentTransform;
+      vk::CompositeAlphaFlagsKHR supportedCompositeAlpha;
+      vk::ImageUsageFlags supportedUsageFlags;
+      vk::SurfaceCounterFlagsEXT supportedSurfaceCounters;
+    };
+    static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct SurfaceCapabilities2EXT
+  struct SurfaceCapabilities2EXT : public layout::SurfaceCapabilities2EXT
   {
     operator VkSurfaceCapabilities2EXT const&() const
     {
@@ -48216,23 +59481,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSurfaceCapabilities2EXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t minImageCount;
-    uint32_t maxImageCount;
-    Extent2D currentExtent;
-    Extent2D minImageExtent;
-    Extent2D maxImageExtent;
-    uint32_t maxImageArrayLayers;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    SurfaceTransformFlagBitsKHR currentTransform;
-    CompositeAlphaFlagsKHR supportedCompositeAlpha;
-    ImageUsageFlags supportedUsageFlags;
-    SurfaceCounterFlagsEXT supportedSurfaceCounters;
+    using layout::SurfaceCapabilities2EXT::sType;
   };
   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!" );
 
   struct SurfaceCapabilitiesKHR
   {
@@ -48265,20 +59517,50 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
+  public:
     uint32_t minImageCount;
     uint32_t maxImageCount;
-    Extent2D currentExtent;
-    Extent2D minImageExtent;
-    Extent2D maxImageExtent;
+    vk::Extent2D currentExtent;
+    vk::Extent2D minImageExtent;
+    vk::Extent2D maxImageExtent;
     uint32_t maxImageArrayLayers;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    SurfaceTransformFlagBitsKHR currentTransform;
-    CompositeAlphaFlagsKHR supportedCompositeAlpha;
-    ImageUsageFlags supportedUsageFlags;
+    vk::SurfaceTransformFlagsKHR supportedTransforms;
+    vk::SurfaceTransformFlagBitsKHR currentTransform;
+    vk::CompositeAlphaFlagsKHR supportedCompositeAlpha;
+    vk::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!" );
+
+  namespace layout
+  {
+    struct SurfaceCapabilities2KHR
+    {
+    protected:
+      SurfaceCapabilities2KHR( vk::SurfaceCapabilitiesKHR surfaceCapabilities_ = vk::SurfaceCapabilitiesKHR() )
+        : surfaceCapabilities( surfaceCapabilities_ )
+      {}
+
+      SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this) = rhs;
+      }
+
+      SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this) = rhs;
+        return *this;
+      }
 
-  struct SurfaceCapabilities2KHR
+    public:
+      vk::StructureType sType = StructureType::eSurfaceCapabilities2KHR;
+      void* pNext = nullptr;
+      vk::SurfaceCapabilitiesKHR surfaceCapabilities;
+    };
+    static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SurfaceCapabilities2KHR : public layout::SurfaceCapabilities2KHR
   {
     operator VkSurfaceCapabilities2KHR const&() const
     {
@@ -48303,25 +59585,50 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSurfaceCapabilities2KHR;
-
-  public:
-    void* pNext = nullptr;
-    SurfaceCapabilitiesKHR surfaceCapabilities;
+    using layout::SurfaceCapabilities2KHR::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct SurfaceCapabilitiesFullScreenExclusiveEXT
+
+  namespace layout
+  {
+    struct SurfaceCapabilitiesFullScreenExclusiveEXT
+    {
+    protected:
+      SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 )
+        : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
+      {}
+
+      SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this) = rhs;
+      }
+
+      SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT;
+      void* pNext = nullptr;
+      vk::Bool32 fullScreenExclusiveSupported;
+    };
+    static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SurfaceCapabilitiesFullScreenExclusiveEXT : public layout::SurfaceCapabilitiesFullScreenExclusiveEXT
   {
-    SurfaceCapabilitiesFullScreenExclusiveEXT( Bool32 fullScreenExclusiveSupported_ = 0 )
-      : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
+    SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 )
+      : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( fullScreenExclusiveSupported_ )
     {}
 
     SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs )
-    {
-      *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this) = rhs;
-    }
+      : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( rhs )
+    {}
 
     SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs )
     {
@@ -48335,7 +59642,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SurfaceCapabilitiesFullScreenExclusiveEXT & setFullScreenExclusiveSupported( Bool32 fullScreenExclusiveSupported_ )
+    SurfaceCapabilitiesFullScreenExclusiveEXT & setFullScreenExclusiveSupported( vk::Bool32 fullScreenExclusiveSupported_ )
     {
       fullScreenExclusiveSupported = fullScreenExclusiveSupported_;
       return *this;
@@ -48364,13 +59671,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 fullScreenExclusiveSupported;
+    using layout::SurfaceCapabilitiesFullScreenExclusiveEXT::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   struct SurfaceFormatKHR
@@ -48396,12 +59700,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-    Format format;
-    ColorSpaceKHR colorSpace;
+  public:
+    vk::Format format;
+    vk::ColorSpaceKHR colorSpace;
   };
   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
+  namespace layout
+  {
+    struct SurfaceFormat2KHR
+    {
+    protected:
+      SurfaceFormat2KHR( vk::SurfaceFormatKHR surfaceFormat_ = vk::SurfaceFormatKHR() )
+        : surfaceFormat( surfaceFormat_ )
+      {}
+
+      SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceFormat2KHR*>(this) = rhs;
+      }
+
+      SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceFormat2KHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSurfaceFormat2KHR;
+      void* pNext = nullptr;
+      vk::SurfaceFormatKHR surfaceFormat;
+    };
+    static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SurfaceFormat2KHR : public layout::SurfaceFormat2KHR
   {
     operator VkSurfaceFormat2KHR const&() const
     {
@@ -48426,25 +59760,50 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSurfaceFormat2KHR;
-
-  public:
-    void* pNext = nullptr;
-    SurfaceFormatKHR surfaceFormat;
+    using layout::SurfaceFormat2KHR::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct SurfaceFullScreenExclusiveInfoEXT
+
+  namespace layout
+  {
+    struct SurfaceFullScreenExclusiveInfoEXT
+    {
+    protected:
+      SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault )
+        : fullScreenExclusive( fullScreenExclusive_ )
+      {}
+
+      SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(this) = rhs;
+      }
+
+      SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT;
+      void* pNext = nullptr;
+      vk::FullScreenExclusiveEXT fullScreenExclusive;
+    };
+    static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SurfaceFullScreenExclusiveInfoEXT : public layout::SurfaceFullScreenExclusiveInfoEXT
   {
-    SurfaceFullScreenExclusiveInfoEXT( FullScreenExclusiveEXT fullScreenExclusive_ = FullScreenExclusiveEXT::eDefault )
-      : fullScreenExclusive( fullScreenExclusive_ )
+    SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault )
+      : layout::SurfaceFullScreenExclusiveInfoEXT( fullScreenExclusive_ )
     {}
 
     SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(this) = rhs;
-    }
+      : layout::SurfaceFullScreenExclusiveInfoEXT( rhs )
+    {}
 
     SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs )
     {
@@ -48458,7 +59817,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SurfaceFullScreenExclusiveInfoEXT & setFullScreenExclusive( FullScreenExclusiveEXT fullScreenExclusive_ )
+    SurfaceFullScreenExclusiveInfoEXT & setFullScreenExclusive( vk::FullScreenExclusiveEXT fullScreenExclusive_ )
     {
       fullScreenExclusive = fullScreenExclusive_;
       return *this;
@@ -48487,26 +59846,51 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT;
-
-  public:
-    void* pNext = nullptr;
-    FullScreenExclusiveEXT fullScreenExclusive;
+    using layout::SurfaceFullScreenExclusiveInfoEXT::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct SurfaceFullScreenExclusiveWin32InfoEXT
+
+  namespace layout
+  {
+    struct SurfaceFullScreenExclusiveWin32InfoEXT
+    {
+    protected:
+      SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 )
+        : hmonitor( hmonitor_ )
+      {}
+
+      SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(this) = rhs;
+      }
+
+      SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT;
+      const void* pNext = nullptr;
+      HMONITOR hmonitor;
+    };
+    static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SurfaceFullScreenExclusiveWin32InfoEXT : public layout::SurfaceFullScreenExclusiveWin32InfoEXT
   {
     SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 )
-      : hmonitor( hmonitor_ )
+      : layout::SurfaceFullScreenExclusiveWin32InfoEXT( hmonitor_ )
     {}
 
     SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(this) = rhs;
-    }
+      : layout::SurfaceFullScreenExclusiveWin32InfoEXT( rhs )
+    {}
 
     SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs )
     {
@@ -48549,25 +59933,49 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    HMONITOR hmonitor;
+    using layout::SurfaceFullScreenExclusiveWin32InfoEXT::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct SurfaceProtectedCapabilitiesKHR
+  namespace layout
+  {
+    struct SurfaceProtectedCapabilitiesKHR
+    {
+    protected:
+      SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 )
+        : supportsProtected( supportsProtected_ )
+      {}
+
+      SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(this) = rhs;
+      }
+
+      SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs )
+      {
+        *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR;
+      const void* pNext = nullptr;
+      vk::Bool32 supportsProtected;
+    };
+    static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SurfaceProtectedCapabilitiesKHR : public layout::SurfaceProtectedCapabilitiesKHR
   {
-    SurfaceProtectedCapabilitiesKHR( Bool32 supportsProtected_ = 0 )
-      : supportsProtected( supportsProtected_ )
+    SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 )
+      : layout::SurfaceProtectedCapabilitiesKHR( supportsProtected_ )
     {}
 
     SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs )
-    {
-      *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(this) = rhs;
-    }
+      : layout::SurfaceProtectedCapabilitiesKHR( rhs )
+    {}
 
     SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs )
     {
@@ -48581,7 +59989,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SurfaceProtectedCapabilitiesKHR & setSupportsProtected( Bool32 supportsProtected_ )
+    SurfaceProtectedCapabilitiesKHR & setSupportsProtected( vk::Bool32 supportsProtected_ )
     {
       supportsProtected = supportsProtected_;
       return *this;
@@ -48610,24 +60018,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 supportsProtected;
+    using layout::SurfaceProtectedCapabilitiesKHR::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct SwapchainCounterCreateInfoEXT
+    {
+    protected:
+      SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() )
+        : surfaceCounters( surfaceCounters_ )
+      {}
+
+      SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this) = rhs;
+      }
 
-  struct SwapchainCounterCreateInfoEXT
+      SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::SurfaceCounterFlagsEXT surfaceCounters;
+    };
+    static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SwapchainCounterCreateInfoEXT : public layout::SwapchainCounterCreateInfoEXT
   {
-    SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
-      : surfaceCounters( surfaceCounters_ )
+    SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() )
+      : layout::SwapchainCounterCreateInfoEXT( surfaceCounters_ )
     {}
 
     SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::SwapchainCounterCreateInfoEXT( rhs )
+    {}
 
     SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
     {
@@ -48641,7 +60073,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SwapchainCounterCreateInfoEXT & setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
+    SwapchainCounterCreateInfoEXT & setSurfaceCounters( vk::SurfaceCounterFlagsEXT surfaceCounters_ )
     {
       surfaceCounters = surfaceCounters_;
       return *this;
@@ -48670,54 +60102,108 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    SurfaceCounterFlagsEXT surfaceCounters;
+    using layout::SwapchainCounterCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct SwapchainCreateInfoKHR
+    {
+    protected:
+      SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(),
+                              vk::SurfaceKHR surface_ = vk::SurfaceKHR(),
+                              uint32_t minImageCount_ = 0,
+                              vk::Format imageFormat_ = vk::Format::eUndefined,
+                              vk::ColorSpaceKHR imageColorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear,
+                              vk::Extent2D imageExtent_ = vk::Extent2D(),
+                              uint32_t imageArrayLayers_ = 0,
+                              vk::ImageUsageFlags imageUsage_ = vk::ImageUsageFlags(),
+                              vk::SharingMode imageSharingMode_ = vk::SharingMode::eExclusive,
+                              uint32_t queueFamilyIndexCount_ = 0,
+                              const uint32_t* pQueueFamilyIndices_ = nullptr,
+                              vk::SurfaceTransformFlagBitsKHR preTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
+                              vk::CompositeAlphaFlagBitsKHR compositeAlpha_ = vk::CompositeAlphaFlagBitsKHR::eOpaque,
+                              vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate,
+                              vk::Bool32 clipped_ = 0,
+                              vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() )
+        : flags( flags_ )
+        , surface( surface_ )
+        , minImageCount( minImageCount_ )
+        , imageFormat( imageFormat_ )
+        , imageColorSpace( imageColorSpace_ )
+        , imageExtent( imageExtent_ )
+        , imageArrayLayers( imageArrayLayers_ )
+        , imageUsage( imageUsage_ )
+        , imageSharingMode( imageSharingMode_ )
+        , queueFamilyIndexCount( queueFamilyIndexCount_ )
+        , pQueueFamilyIndices( pQueueFamilyIndices_ )
+        , preTransform( preTransform_ )
+        , compositeAlpha( compositeAlpha_ )
+        , presentMode( presentMode_ )
+        , clipped( clipped_ )
+        , oldSwapchain( oldSwapchain_ )
+      {}
 
-  struct SwapchainCreateInfoKHR
+      SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this) = rhs;
+      }
+
+      SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSwapchainCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::SwapchainCreateFlagsKHR flags;
+      vk::SurfaceKHR surface;
+      uint32_t minImageCount;
+      vk::Format imageFormat;
+      vk::ColorSpaceKHR imageColorSpace;
+      vk::Extent2D imageExtent;
+      uint32_t imageArrayLayers;
+      vk::ImageUsageFlags imageUsage;
+      vk::SharingMode imageSharingMode;
+      uint32_t queueFamilyIndexCount;
+      const uint32_t* pQueueFamilyIndices;
+      vk::SurfaceTransformFlagBitsKHR preTransform;
+      vk::CompositeAlphaFlagBitsKHR compositeAlpha;
+      vk::PresentModeKHR presentMode;
+      vk::Bool32 clipped;
+      vk::SwapchainKHR oldSwapchain;
+    };
+    static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SwapchainCreateInfoKHR : public layout::SwapchainCreateInfoKHR
   {
-    SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(),
-                            SurfaceKHR surface_ = SurfaceKHR(),
+    SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(),
+                            vk::SurfaceKHR surface_ = vk::SurfaceKHR(),
                             uint32_t minImageCount_ = 0,
-                            Format imageFormat_ = Format::eUndefined,
-                            ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear,
-                            Extent2D imageExtent_ = Extent2D(),
+                            vk::Format imageFormat_ = vk::Format::eUndefined,
+                            vk::ColorSpaceKHR imageColorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear,
+                            vk::Extent2D imageExtent_ = vk::Extent2D(),
                             uint32_t imageArrayLayers_ = 0,
-                            ImageUsageFlags imageUsage_ = ImageUsageFlags(),
-                            SharingMode imageSharingMode_ = SharingMode::eExclusive,
+                            vk::ImageUsageFlags imageUsage_ = vk::ImageUsageFlags(),
+                            vk::SharingMode imageSharingMode_ = vk::SharingMode::eExclusive,
                             uint32_t queueFamilyIndexCount_ = 0,
                             const uint32_t* pQueueFamilyIndices_ = nullptr,
-                            SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity,
-                            CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque,
-                            PresentModeKHR presentMode_ = PresentModeKHR::eImmediate,
-                            Bool32 clipped_ = 0,
-                            SwapchainKHR oldSwapchain_ = SwapchainKHR() )
-      : flags( flags_ )
-      , surface( surface_ )
-      , minImageCount( minImageCount_ )
-      , imageFormat( imageFormat_ )
-      , imageColorSpace( imageColorSpace_ )
-      , imageExtent( imageExtent_ )
-      , imageArrayLayers( imageArrayLayers_ )
-      , imageUsage( imageUsage_ )
-      , imageSharingMode( imageSharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
-      , preTransform( preTransform_ )
-      , compositeAlpha( compositeAlpha_ )
-      , presentMode( presentMode_ )
-      , clipped( clipped_ )
-      , oldSwapchain( oldSwapchain_ )
+                            vk::SurfaceTransformFlagBitsKHR preTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
+                            vk::CompositeAlphaFlagBitsKHR compositeAlpha_ = vk::CompositeAlphaFlagBitsKHR::eOpaque,
+                            vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate,
+                            vk::Bool32 clipped_ = 0,
+                            vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() )
+      : layout::SwapchainCreateInfoKHR( flags_, surface_, minImageCount_, imageFormat_, imageColorSpace_, imageExtent_, imageArrayLayers_, imageUsage_, imageSharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, preTransform_, compositeAlpha_, presentMode_, clipped_, oldSwapchain_ )
     {}
 
     SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::SwapchainCreateInfoKHR( rhs )
+    {}
 
     SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
     {
@@ -48731,13 +60217,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setFlags( SwapchainCreateFlagsKHR flags_ )
+    SwapchainCreateInfoKHR & setFlags( vk::SwapchainCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setSurface( SurfaceKHR surface_ )
+    SwapchainCreateInfoKHR & setSurface( vk::SurfaceKHR surface_ )
     {
       surface = surface_;
       return *this;
@@ -48749,19 +60235,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setImageFormat( Format imageFormat_ )
+    SwapchainCreateInfoKHR & setImageFormat( vk::Format imageFormat_ )
     {
       imageFormat = imageFormat_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
+    SwapchainCreateInfoKHR & setImageColorSpace( vk::ColorSpaceKHR imageColorSpace_ )
     {
       imageColorSpace = imageColorSpace_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setImageExtent( Extent2D imageExtent_ )
+    SwapchainCreateInfoKHR & setImageExtent( vk::Extent2D imageExtent_ )
     {
       imageExtent = imageExtent_;
       return *this;
@@ -48773,13 +60259,13 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setImageUsage( ImageUsageFlags imageUsage_ )
+    SwapchainCreateInfoKHR & setImageUsage( vk::ImageUsageFlags imageUsage_ )
     {
       imageUsage = imageUsage_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setImageSharingMode( SharingMode imageSharingMode_ )
+    SwapchainCreateInfoKHR & setImageSharingMode( vk::SharingMode imageSharingMode_ )
     {
       imageSharingMode = imageSharingMode_;
       return *this;
@@ -48797,31 +60283,31 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
+    SwapchainCreateInfoKHR & setPreTransform( vk::SurfaceTransformFlagBitsKHR preTransform_ )
     {
       preTransform = preTransform_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
+    SwapchainCreateInfoKHR & setCompositeAlpha( vk::CompositeAlphaFlagBitsKHR compositeAlpha_ )
     {
       compositeAlpha = compositeAlpha_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setPresentMode( PresentModeKHR presentMode_ )
+    SwapchainCreateInfoKHR & setPresentMode( vk::PresentModeKHR presentMode_ )
     {
       presentMode = presentMode_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setClipped( Bool32 clipped_ )
+    SwapchainCreateInfoKHR & setClipped( vk::Bool32 clipped_ )
     {
       clipped = clipped_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR & setOldSwapchain( SwapchainKHR oldSwapchain_ )
+    SwapchainCreateInfoKHR & setOldSwapchain( vk::SwapchainKHR oldSwapchain_ )
     {
       oldSwapchain = oldSwapchain_;
       return *this;
@@ -48865,39 +60351,48 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSwapchainCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainCreateFlagsKHR flags;
-    SurfaceKHR surface;
-    uint32_t minImageCount;
-    Format imageFormat;
-    ColorSpaceKHR imageColorSpace;
-    Extent2D imageExtent;
-    uint32_t imageArrayLayers;
-    ImageUsageFlags imageUsage;
-    SharingMode imageSharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
-    SurfaceTransformFlagBitsKHR preTransform;
-    CompositeAlphaFlagBitsKHR compositeAlpha;
-    PresentModeKHR presentMode;
-    Bool32 clipped;
-    SwapchainKHR oldSwapchain;
+    using layout::SwapchainCreateInfoKHR::sType;
   };
   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!" );
 
-  struct SwapchainDisplayNativeHdrCreateInfoAMD
+  namespace layout
   {
-    SwapchainDisplayNativeHdrCreateInfoAMD( Bool32 localDimmingEnable_ = 0 )
-      : localDimmingEnable( localDimmingEnable_ )
+    struct SwapchainDisplayNativeHdrCreateInfoAMD
+    {
+    protected:
+      SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 )
+        : localDimmingEnable( localDimmingEnable_ )
+      {}
+
+      SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs )
+      {
+        *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(this) = rhs;
+      }
+
+      SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs )
+      {
+        *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD;
+      const void* pNext = nullptr;
+      vk::Bool32 localDimmingEnable;
+    };
+    static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "layout struct and wrapper have different size!" );
+  }
+
+  struct SwapchainDisplayNativeHdrCreateInfoAMD : public layout::SwapchainDisplayNativeHdrCreateInfoAMD
+  {
+    SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 )
+      : layout::SwapchainDisplayNativeHdrCreateInfoAMD( localDimmingEnable_ )
     {}
 
     SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs )
-    {
-      *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(this) = rhs;
-    }
+      : layout::SwapchainDisplayNativeHdrCreateInfoAMD( rhs )
+    {}
 
     SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs )
     {
@@ -48911,7 +60406,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    SwapchainDisplayNativeHdrCreateInfoAMD & setLocalDimmingEnable( Bool32 localDimmingEnable_ )
+    SwapchainDisplayNativeHdrCreateInfoAMD & setLocalDimmingEnable( vk::Bool32 localDimmingEnable_ )
     {
       localDimmingEnable = localDimmingEnable_;
       return *this;
@@ -48940,15 +60435,40 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 localDimmingEnable;
+    using layout::SwapchainDisplayNativeHdrCreateInfoAMD::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct TextureLODGatherFormatPropertiesAMD
+    {
+    protected:
+      TextureLODGatherFormatPropertiesAMD( vk::Bool32 supportsTextureGatherLODBiasAMD_ = 0 )
+        : supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ )
+      {}
+
+      TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs )
+      {
+        *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this) = rhs;
+      }
+
+      TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs )
+      {
+        *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
+      void* pNext = nullptr;
+      vk::Bool32 supportsTextureGatherLODBiasAMD;
+    };
+    static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "layout struct and wrapper have different size!" );
+  }
 
-  struct TextureLODGatherFormatPropertiesAMD
+  struct TextureLODGatherFormatPropertiesAMD : public layout::TextureLODGatherFormatPropertiesAMD
   {
     operator VkTextureLODGatherFormatPropertiesAMD const&() const
     {
@@ -48973,28 +60493,56 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 supportsTextureGatherLODBiasAMD;
+    using layout::TextureLODGatherFormatPropertiesAMD::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ValidationCacheCreateInfoEXT
+    {
+    protected:
+      ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(),
+                                    size_t initialDataSize_ = 0,
+                                    const void* pInitialData_ = nullptr )
+        : flags( flags_ )
+        , initialDataSize( initialDataSize_ )
+        , pInitialData( pInitialData_ )
+      {}
+
+      ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this) = rhs;
+      }
+
+      ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs )
+      {
+        *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
+      const void* pNext = nullptr;
+      vk::ValidationCacheCreateFlagsEXT flags;
+      size_t initialDataSize;
+      const void* pInitialData;
+    };
+    static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct ValidationCacheCreateInfoEXT
+  struct ValidationCacheCreateInfoEXT : public layout::ValidationCacheCreateInfoEXT
   {
-    ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(),
+    ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(),
                                   size_t initialDataSize_ = 0,
                                   const void* pInitialData_ = nullptr )
-      : flags( flags_ )
-      , initialDataSize( initialDataSize_ )
-      , pInitialData( pInitialData_ )
+      : layout::ValidationCacheCreateInfoEXT( flags_, initialDataSize_, pInitialData_ )
     {}
 
     ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs )
-    {
-      *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this) = rhs;
-    }
+      : layout::ValidationCacheCreateInfoEXT( rhs )
+    {}
 
     ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs )
     {
@@ -49008,7 +60556,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ValidationCacheCreateInfoEXT & setFlags( ValidationCacheCreateFlagsEXT flags_ )
+    ValidationCacheCreateInfoEXT & setFlags( vk::ValidationCacheCreateFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
@@ -49051,32 +60599,60 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ValidationCacheCreateFlagsEXT flags;
-    size_t initialDataSize;
-    const void* pInitialData;
+    using layout::ValidationCacheCreateInfoEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ValidationFeaturesEXT
+    {
+    protected:
+      ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0,
+                             const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
+                             uint32_t disabledValidationFeatureCount_ = 0,
+                             const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr )
+        : enabledValidationFeatureCount( enabledValidationFeatureCount_ )
+        , pEnabledValidationFeatures( pEnabledValidationFeatures_ )
+        , disabledValidationFeatureCount( disabledValidationFeatureCount_ )
+        , pDisabledValidationFeatures( pDisabledValidationFeatures_ )
+      {}
+
+      ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkValidationFeaturesEXT*>(this) = rhs;
+      }
 
-  struct ValidationFeaturesEXT
+      ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs )
+      {
+        *reinterpret_cast<VkValidationFeaturesEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eValidationFeaturesEXT;
+      const void* pNext = nullptr;
+      uint32_t enabledValidationFeatureCount;
+      const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures;
+      uint32_t disabledValidationFeatureCount;
+      const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures;
+    };
+    static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ValidationFeaturesEXT : public layout::ValidationFeaturesEXT
   {
     ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0,
-                           const ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
+                           const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
                            uint32_t disabledValidationFeatureCount_ = 0,
-                           const ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr )
-      : enabledValidationFeatureCount( enabledValidationFeatureCount_ )
-      , pEnabledValidationFeatures( pEnabledValidationFeatures_ )
-      , disabledValidationFeatureCount( disabledValidationFeatureCount_ )
-      , pDisabledValidationFeatures( pDisabledValidationFeatures_ )
+                           const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr )
+      : layout::ValidationFeaturesEXT( enabledValidationFeatureCount_, pEnabledValidationFeatures_, disabledValidationFeatureCount_, pDisabledValidationFeatures_ )
     {}
 
     ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs )
-    {
-      *reinterpret_cast<VkValidationFeaturesEXT*>(this) = rhs;
-    }
+      : layout::ValidationFeaturesEXT( rhs )
+    {}
 
     ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs )
     {
@@ -49096,7 +60672,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ValidationFeaturesEXT & setPEnabledValidationFeatures( const ValidationFeatureEnableEXT* pEnabledValidationFeatures_ )
+    ValidationFeaturesEXT & setPEnabledValidationFeatures( const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ )
     {
       pEnabledValidationFeatures = pEnabledValidationFeatures_;
       return *this;
@@ -49108,7 +60684,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ValidationFeaturesEXT & setPDisabledValidationFeatures( const ValidationFeatureDisableEXT* pDisabledValidationFeatures_ )
+    ValidationFeaturesEXT & setPDisabledValidationFeatures( const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ )
     {
       pDisabledValidationFeatures = pDisabledValidationFeatures_;
       return *this;
@@ -49140,29 +60716,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eValidationFeaturesEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t enabledValidationFeatureCount;
-    const ValidationFeatureEnableEXT* pEnabledValidationFeatures;
-    uint32_t disabledValidationFeatureCount;
-    const ValidationFeatureDisableEXT* pDisabledValidationFeatures;
+    using layout::ValidationFeaturesEXT::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct ValidationFlagsEXT
+    {
+    protected:
+      ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
+                          const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
+        : disabledValidationCheckCount( disabledValidationCheckCount_ )
+        , pDisabledValidationChecks( pDisabledValidationChecks_ )
+      {}
 
-  struct ValidationFlagsEXT
+      ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
+      {
+        *reinterpret_cast<VkValidationFlagsEXT*>(this) = rhs;
+      }
+
+      ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
+      {
+        *reinterpret_cast<VkValidationFlagsEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eValidationFlagsEXT;
+      const void* pNext = nullptr;
+      uint32_t disabledValidationCheckCount;
+      const vk::ValidationCheckEXT* pDisabledValidationChecks;
+    };
+    static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ValidationFlagsEXT : public layout::ValidationFlagsEXT
   {
     ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
-                        const ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
-      : disabledValidationCheckCount( disabledValidationCheckCount_ )
-      , pDisabledValidationChecks( pDisabledValidationChecks_ )
+                        const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
+      : layout::ValidationFlagsEXT( disabledValidationCheckCount_, pDisabledValidationChecks_ )
     {}
 
     ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
-    {
-      *reinterpret_cast<VkValidationFlagsEXT*>(this) = rhs;
-    }
+      : layout::ValidationFlagsEXT( rhs )
+    {}
 
     ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
     {
@@ -49182,7 +60781,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ValidationFlagsEXT & setPDisabledValidationChecks( const ValidationCheckEXT* pDisabledValidationChecks_ )
+    ValidationFlagsEXT & setPDisabledValidationChecks( const vk::ValidationCheckEXT* pDisabledValidationChecks_ )
     {
       pDisabledValidationChecks = pDisabledValidationChecks_;
       return *this;
@@ -49212,28 +60811,54 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eValidationFlagsEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t disabledValidationCheckCount;
-    const ValidationCheckEXT* pDisabledValidationChecks;
+    using layout::ValidationFlagsEXT::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_VI_NN
-  struct ViSurfaceCreateInfoNN
+
+  namespace layout
   {
-    ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(),
+    struct ViSurfaceCreateInfoNN
+    {
+    protected:
+      ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(),
+                             void* window_ = nullptr )
+        : flags( flags_ )
+        , window( window_ )
+      {}
+
+      ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
+      {
+        *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this) = rhs;
+      }
+
+      ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
+      {
+        *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eViSurfaceCreateInfoNN;
+      const void* pNext = nullptr;
+      vk::ViSurfaceCreateFlagsNN flags;
+      void* window;
+    };
+    static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "layout struct and wrapper have different size!" );
+  }
+
+  struct ViSurfaceCreateInfoNN : public layout::ViSurfaceCreateInfoNN
+  {
+    ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(),
                            void* window_ = nullptr )
-      : flags( flags_ )
-      , window( window_ )
+      : layout::ViSurfaceCreateInfoNN( flags_, window_ )
     {}
 
     ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
-    {
-      *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this) = rhs;
-    }
+      : layout::ViSurfaceCreateInfoNN( rhs )
+    {}
 
     ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
     {
@@ -49247,7 +60872,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    ViSurfaceCreateInfoNN & setFlags( ViSurfaceCreateFlagsNN flags_ )
+    ViSurfaceCreateInfoNN & setFlags( vk::ViSurfaceCreateFlagsNN flags_ )
     {
       flags = flags_;
       return *this;
@@ -49283,31 +60908,59 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eViSurfaceCreateInfoNN;
-
-  public:
-    const void* pNext = nullptr;
-    ViSurfaceCreateFlagsNN flags;
-    void* window;
+    using layout::ViSurfaceCreateInfoNN::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_VI_NN*/
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  struct WaylandSurfaceCreateInfoKHR
+
+  namespace layout
+  {
+    struct WaylandSurfaceCreateInfoKHR
+    {
+    protected:
+      WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(),
+                                   struct wl_display* display_ = nullptr,
+                                   struct wl_surface* surface_ = nullptr )
+        : flags( flags_ )
+        , display( display_ )
+        , surface( surface_ )
+      {}
+
+      WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this) = rhs;
+      }
+
+      WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::WaylandSurfaceCreateFlagsKHR flags;
+      struct wl_display* display;
+      struct wl_surface* surface;
+    };
+    static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct WaylandSurfaceCreateInfoKHR : public layout::WaylandSurfaceCreateInfoKHR
   {
-    WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(),
+    WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(),
                                  struct wl_display* display_ = nullptr,
                                  struct wl_surface* surface_ = nullptr )
-      : flags( flags_ )
-      , display( display_ )
-      , surface( surface_ )
+      : layout::WaylandSurfaceCreateInfoKHR( flags_, display_, surface_ )
     {}
 
     WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::WaylandSurfaceCreateInfoKHR( rhs )
+    {}
 
     WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
     {
@@ -49321,7 +60974,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    WaylandSurfaceCreateInfoKHR & setFlags( WaylandSurfaceCreateFlagsKHR flags_ )
+    WaylandSurfaceCreateInfoKHR & setFlags( vk::WaylandSurfaceCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
@@ -49364,40 +61017,75 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    WaylandSurfaceCreateFlagsKHR flags;
-    struct wl_display* display;
-    struct wl_surface* surface;
+    using layout::WaylandSurfaceCreateInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct Win32KeyedMutexAcquireReleaseInfoKHR
+
+  namespace layout
+  {
+    struct Win32KeyedMutexAcquireReleaseInfoKHR
+    {
+    protected:
+      Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0,
+                                            const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
+                                            const uint64_t* pAcquireKeys_ = nullptr,
+                                            const uint32_t* pAcquireTimeouts_ = nullptr,
+                                            uint32_t releaseCount_ = 0,
+                                            const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
+                                            const uint64_t* pReleaseKeys_ = nullptr )
+        : acquireCount( acquireCount_ )
+        , pAcquireSyncs( pAcquireSyncs_ )
+        , pAcquireKeys( pAcquireKeys_ )
+        , pAcquireTimeouts( pAcquireTimeouts_ )
+        , releaseCount( releaseCount_ )
+        , pReleaseSyncs( pReleaseSyncs_ )
+        , pReleaseKeys( pReleaseKeys_ )
+      {}
+
+      Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this) = rhs;
+      }
+
+      Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
+      const void* pNext = nullptr;
+      uint32_t acquireCount;
+      const vk::DeviceMemory* pAcquireSyncs;
+      const uint64_t* pAcquireKeys;
+      const uint32_t* pAcquireTimeouts;
+      uint32_t releaseCount;
+      const vk::DeviceMemory* pReleaseSyncs;
+      const uint64_t* pReleaseKeys;
+    };
+    static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct Win32KeyedMutexAcquireReleaseInfoKHR : public layout::Win32KeyedMutexAcquireReleaseInfoKHR
   {
     Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0,
-                                          const DeviceMemory* pAcquireSyncs_ = nullptr,
+                                          const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
                                           const uint64_t* pAcquireKeys_ = nullptr,
                                           const uint32_t* pAcquireTimeouts_ = nullptr,
                                           uint32_t releaseCount_ = 0,
-                                          const DeviceMemory* pReleaseSyncs_ = nullptr,
+                                          const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
                                           const uint64_t* pReleaseKeys_ = nullptr )
-      : acquireCount( acquireCount_ )
-      , pAcquireSyncs( pAcquireSyncs_ )
-      , pAcquireKeys( pAcquireKeys_ )
-      , pAcquireTimeouts( pAcquireTimeouts_ )
-      , releaseCount( releaseCount_ )
-      , pReleaseSyncs( pReleaseSyncs_ )
-      , pReleaseKeys( pReleaseKeys_ )
+      : layout::Win32KeyedMutexAcquireReleaseInfoKHR( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeouts_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ )
     {}
 
     Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this) = rhs;
-    }
+      : layout::Win32KeyedMutexAcquireReleaseInfoKHR( rhs )
+    {}
 
     Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
     {
@@ -49417,7 +61105,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
+    Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireSyncs( const vk::DeviceMemory* pAcquireSyncs_ )
     {
       pAcquireSyncs = pAcquireSyncs_;
       return *this;
@@ -49441,7 +61129,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
+    Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseSyncs( const vk::DeviceMemory* pReleaseSyncs_ )
     {
       pReleaseSyncs = pReleaseSyncs_;
       return *this;
@@ -49482,44 +61170,75 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t acquireCount;
-    const DeviceMemory* pAcquireSyncs;
-    const uint64_t* pAcquireKeys;
-    const uint32_t* pAcquireTimeouts;
-    uint32_t releaseCount;
-    const DeviceMemory* pReleaseSyncs;
-    const uint64_t* pReleaseKeys;
+    using layout::Win32KeyedMutexAcquireReleaseInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct Win32KeyedMutexAcquireReleaseInfoNV
+
+  namespace layout
+  {
+    struct Win32KeyedMutexAcquireReleaseInfoNV
+    {
+    protected:
+      Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0,
+                                           const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
+                                           const uint64_t* pAcquireKeys_ = nullptr,
+                                           const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr,
+                                           uint32_t releaseCount_ = 0,
+                                           const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
+                                           const uint64_t* pReleaseKeys_ = nullptr )
+        : acquireCount( acquireCount_ )
+        , pAcquireSyncs( pAcquireSyncs_ )
+        , pAcquireKeys( pAcquireKeys_ )
+        , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
+        , releaseCount( releaseCount_ )
+        , pReleaseSyncs( pReleaseSyncs_ )
+        , pReleaseKeys( pReleaseKeys_ )
+      {}
+
+      Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this) = rhs;
+      }
+
+      Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
+      {
+        *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
+      const void* pNext = nullptr;
+      uint32_t acquireCount;
+      const vk::DeviceMemory* pAcquireSyncs;
+      const uint64_t* pAcquireKeys;
+      const uint32_t* pAcquireTimeoutMilliseconds;
+      uint32_t releaseCount;
+      const vk::DeviceMemory* pReleaseSyncs;
+      const uint64_t* pReleaseKeys;
+    };
+    static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct Win32KeyedMutexAcquireReleaseInfoNV : public layout::Win32KeyedMutexAcquireReleaseInfoNV
   {
     Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0,
-                                         const DeviceMemory* pAcquireSyncs_ = nullptr,
+                                         const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
                                          const uint64_t* pAcquireKeys_ = nullptr,
                                          const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr,
                                          uint32_t releaseCount_ = 0,
-                                         const DeviceMemory* pReleaseSyncs_ = nullptr,
+                                         const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
                                          const uint64_t* pReleaseKeys_ = nullptr )
-      : acquireCount( acquireCount_ )
-      , pAcquireSyncs( pAcquireSyncs_ )
-      , pAcquireKeys( pAcquireKeys_ )
-      , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
-      , releaseCount( releaseCount_ )
-      , pReleaseSyncs( pReleaseSyncs_ )
-      , pReleaseKeys( pReleaseKeys_ )
+      : layout::Win32KeyedMutexAcquireReleaseInfoNV( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeoutMilliseconds_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ )
     {}
 
     Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
-    {
-      *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this) = rhs;
-    }
+      : layout::Win32KeyedMutexAcquireReleaseInfoNV( rhs )
+    {}
 
     Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
     {
@@ -49539,7 +61258,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
+    Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireSyncs( const vk::DeviceMemory* pAcquireSyncs_ )
     {
       pAcquireSyncs = pAcquireSyncs_;
       return *this;
@@ -49563,7 +61282,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
+    Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseSyncs( const vk::DeviceMemory* pReleaseSyncs_ )
     {
       pReleaseSyncs = pReleaseSyncs_;
       return *this;
@@ -49604,36 +61323,59 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t acquireCount;
-    const DeviceMemory* pAcquireSyncs;
-    const uint64_t* pAcquireKeys;
-    const uint32_t* pAcquireTimeoutMilliseconds;
-    uint32_t releaseCount;
-    const DeviceMemory* pReleaseSyncs;
-    const uint64_t* pReleaseKeys;
+    using layout::Win32KeyedMutexAcquireReleaseInfoNV::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct Win32SurfaceCreateInfoKHR
+
+  namespace layout
+  {
+    struct Win32SurfaceCreateInfoKHR
+    {
+    protected:
+      Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(),
+                                 HINSTANCE hinstance_ = 0,
+                                 HWND hwnd_ = 0 )
+        : flags( flags_ )
+        , hinstance( hinstance_ )
+        , hwnd( hwnd_ )
+      {}
+
+      Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this) = rhs;
+      }
+
+      Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::Win32SurfaceCreateFlagsKHR flags;
+      HINSTANCE hinstance;
+      HWND hwnd;
+    };
+    static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct Win32SurfaceCreateInfoKHR : public layout::Win32SurfaceCreateInfoKHR
   {
-    Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(),
+    Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(),
                                HINSTANCE hinstance_ = 0,
                                HWND hwnd_ = 0 )
-      : flags( flags_ )
-      , hinstance( hinstance_ )
-      , hwnd( hwnd_ )
+      : layout::Win32SurfaceCreateInfoKHR( flags_, hinstance_, hwnd_ )
     {}
 
     Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::Win32SurfaceCreateInfoKHR( rhs )
+    {}
 
     Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
     {
@@ -49647,7 +61389,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    Win32SurfaceCreateInfoKHR & setFlags( Win32SurfaceCreateFlagsKHR flags_ )
+    Win32SurfaceCreateInfoKHR & setFlags( vk::Win32SurfaceCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
@@ -49690,41 +61432,77 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Win32SurfaceCreateFlagsKHR flags;
-    HINSTANCE hinstance;
-    HWND hwnd;
+    using layout::Win32SurfaceCreateInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  struct WriteDescriptorSet
+  namespace layout
+  {
+    struct WriteDescriptorSet
+    {
+    protected:
+      WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
+                          uint32_t dstBinding_ = 0,
+                          uint32_t dstArrayElement_ = 0,
+                          uint32_t descriptorCount_ = 0,
+                          vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+                          const vk::DescriptorImageInfo* pImageInfo_ = nullptr,
+                          const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr,
+                          const vk::BufferView* pTexelBufferView_ = nullptr )
+        : dstSet( dstSet_ )
+        , dstBinding( dstBinding_ )
+        , dstArrayElement( dstArrayElement_ )
+        , descriptorCount( descriptorCount_ )
+        , descriptorType( descriptorType_ )
+        , pImageInfo( pImageInfo_ )
+        , pBufferInfo( pBufferInfo_ )
+        , pTexelBufferView( pTexelBufferView_ )
+      {}
+
+      WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
+      {
+        *reinterpret_cast<VkWriteDescriptorSet*>(this) = rhs;
+      }
+
+      WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
+      {
+        *reinterpret_cast<VkWriteDescriptorSet*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eWriteDescriptorSet;
+      const void* pNext = nullptr;
+      vk::DescriptorSet dstSet;
+      uint32_t dstBinding;
+      uint32_t dstArrayElement;
+      uint32_t descriptorCount;
+      vk::DescriptorType descriptorType;
+      const vk::DescriptorImageInfo* pImageInfo;
+      const vk::DescriptorBufferInfo* pBufferInfo;
+      const vk::BufferView* pTexelBufferView;
+    };
+    static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "layout struct and wrapper have different size!" );
+  }
+
+  struct WriteDescriptorSet : public layout::WriteDescriptorSet
   {
-    WriteDescriptorSet( DescriptorSet dstSet_ = DescriptorSet(),
+    WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
                         uint32_t dstBinding_ = 0,
                         uint32_t dstArrayElement_ = 0,
                         uint32_t descriptorCount_ = 0,
-                        DescriptorType descriptorType_ = DescriptorType::eSampler,
-                        const DescriptorImageInfo* pImageInfo_ = nullptr,
-                        const DescriptorBufferInfo* pBufferInfo_ = nullptr,
-                        const BufferView* pTexelBufferView_ = nullptr )
-      : dstSet( dstSet_ )
-      , dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
-      , descriptorType( descriptorType_ )
-      , pImageInfo( pImageInfo_ )
-      , pBufferInfo( pBufferInfo_ )
-      , pTexelBufferView( pTexelBufferView_ )
+                        vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+                        const vk::DescriptorImageInfo* pImageInfo_ = nullptr,
+                        const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr,
+                        const vk::BufferView* pTexelBufferView_ = nullptr )
+      : layout::WriteDescriptorSet( dstSet_, dstBinding_, dstArrayElement_, descriptorCount_, descriptorType_, pImageInfo_, pBufferInfo_, pTexelBufferView_ )
     {}
 
     WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
-    {
-      *reinterpret_cast<VkWriteDescriptorSet*>(this) = rhs;
-    }
+      : layout::WriteDescriptorSet( rhs )
+    {}
 
     WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
     {
@@ -49738,7 +61516,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    WriteDescriptorSet & setDstSet( DescriptorSet dstSet_ )
+    WriteDescriptorSet & setDstSet( vk::DescriptorSet dstSet_ )
     {
       dstSet = dstSet_;
       return *this;
@@ -49762,25 +61540,25 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    WriteDescriptorSet & setDescriptorType( DescriptorType descriptorType_ )
+    WriteDescriptorSet & setDescriptorType( vk::DescriptorType descriptorType_ )
     {
       descriptorType = descriptorType_;
       return *this;
     }
 
-    WriteDescriptorSet & setPImageInfo( const DescriptorImageInfo* pImageInfo_ )
+    WriteDescriptorSet & setPImageInfo( const vk::DescriptorImageInfo* pImageInfo_ )
     {
       pImageInfo = pImageInfo_;
       return *this;
     }
 
-    WriteDescriptorSet & setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ )
+    WriteDescriptorSet & setPBufferInfo( const vk::DescriptorBufferInfo* pBufferInfo_ )
     {
       pBufferInfo = pBufferInfo_;
       return *this;
     }
 
-    WriteDescriptorSet & setPTexelBufferView( const BufferView* pTexelBufferView_ )
+    WriteDescriptorSet & setPTexelBufferView( const vk::BufferView* pTexelBufferView_ )
     {
       pTexelBufferView = pTexelBufferView_;
       return *this;
@@ -49816,33 +61594,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eWriteDescriptorSet;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorSet dstSet;
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-    DescriptorType descriptorType;
-    const DescriptorImageInfo* pImageInfo;
-    const DescriptorBufferInfo* pBufferInfo;
-    const BufferView* pTexelBufferView;
+    using layout::WriteDescriptorSet::sType;
   };
   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!" );
+
+  namespace layout
+  {
+    struct WriteDescriptorSetAccelerationStructureNV
+    {
+    protected:
+      WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
+                                                 const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr )
+        : accelerationStructureCount( accelerationStructureCount_ )
+        , pAccelerationStructures( pAccelerationStructures_ )
+      {}
+
+      WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
+      {
+        *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this) = rhs;
+      }
+
+      WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
+      {
+        *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this) = rhs;
+        return *this;
+      }
 
-  struct WriteDescriptorSetAccelerationStructureNV
+    public:
+      vk::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV;
+      const void* pNext = nullptr;
+      uint32_t accelerationStructureCount;
+      const vk::AccelerationStructureNV* pAccelerationStructures;
+    };
+    static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "layout struct and wrapper have different size!" );
+  }
+
+  struct WriteDescriptorSetAccelerationStructureNV : public layout::WriteDescriptorSetAccelerationStructureNV
   {
     WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
-                                               const AccelerationStructureNV* pAccelerationStructures_ = nullptr )
-      : accelerationStructureCount( accelerationStructureCount_ )
-      , pAccelerationStructures( pAccelerationStructures_ )
+                                               const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr )
+      : layout::WriteDescriptorSetAccelerationStructureNV( accelerationStructureCount_, pAccelerationStructures_ )
     {}
 
     WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
-    {
-      *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this) = rhs;
-    }
+      : layout::WriteDescriptorSetAccelerationStructureNV( rhs )
+    {}
 
     WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
     {
@@ -49862,7 +61659,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures( const AccelerationStructureNV* pAccelerationStructures_ )
+    WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures( const vk::AccelerationStructureNV* pAccelerationStructures_ )
     {
       pAccelerationStructures = pAccelerationStructures_;
       return *this;
@@ -49892,27 +61689,52 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t accelerationStructureCount;
-    const AccelerationStructureNV* pAccelerationStructures;
+    using layout::WriteDescriptorSetAccelerationStructureNV::sType;
   };
   static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<WriteDescriptorSetAccelerationStructureNV>::value, "struct wrapper is not a standard layout!" );
+
+  namespace layout
+  {
+    struct WriteDescriptorSetInlineUniformBlockEXT
+    {
+    protected:
+      WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
+                                               const void* pData_ = nullptr )
+        : dataSize( dataSize_ )
+        , pData( pData_ )
+      {}
+
+      WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
+      {
+        *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this) = rhs;
+      }
+
+      WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
+      {
+        *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
+      const void* pNext = nullptr;
+      uint32_t dataSize;
+      const void* pData;
+    };
+    static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "layout struct and wrapper have different size!" );
+  }
 
-  struct WriteDescriptorSetInlineUniformBlockEXT
+  struct WriteDescriptorSetInlineUniformBlockEXT : public layout::WriteDescriptorSetInlineUniformBlockEXT
   {
     WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
                                              const void* pData_ = nullptr )
-      : dataSize( dataSize_ )
-      , pData( pData_ )
+      : layout::WriteDescriptorSetInlineUniformBlockEXT( dataSize_, pData_ )
     {}
 
     WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
-    {
-      *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this) = rhs;
-    }
+      : layout::WriteDescriptorSetInlineUniformBlockEXT( rhs )
+    {}
 
     WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
     {
@@ -49962,30 +61784,58 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t dataSize;
-    const void* pData;
+    using layout::WriteDescriptorSetInlineUniformBlockEXT::sType;
   };
   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!" );
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
-  struct XcbSurfaceCreateInfoKHR
+
+  namespace layout
+  {
+    struct XcbSurfaceCreateInfoKHR
+    {
+    protected:
+      XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(),
+                               xcb_connection_t* connection_ = nullptr,
+                               xcb_window_t window_ = 0 )
+        : flags( flags_ )
+        , connection( connection_ )
+        , window( window_ )
+      {}
+
+      XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this) = rhs;
+      }
+
+      XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::XcbSurfaceCreateFlagsKHR flags;
+      xcb_connection_t* connection;
+      xcb_window_t window;
+    };
+    static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct XcbSurfaceCreateInfoKHR : public layout::XcbSurfaceCreateInfoKHR
   {
-    XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(),
+    XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(),
                              xcb_connection_t* connection_ = nullptr,
                              xcb_window_t window_ = 0 )
-      : flags( flags_ )
-      , connection( connection_ )
-      , window( window_ )
+      : layout::XcbSurfaceCreateInfoKHR( flags_, connection_, window_ )
     {}
 
     XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::XcbSurfaceCreateInfoKHR( rhs )
+    {}
 
     XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
     {
@@ -49999,7 +61849,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    XcbSurfaceCreateInfoKHR & setFlags( XcbSurfaceCreateFlagsKHR flags_ )
+    XcbSurfaceCreateInfoKHR & setFlags( vk::XcbSurfaceCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
@@ -50042,32 +61892,59 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    XcbSurfaceCreateFlagsKHR flags;
-    xcb_connection_t* connection;
-    xcb_window_t window;
+    using layout::XcbSurfaceCreateInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-  struct XlibSurfaceCreateInfoKHR
+
+  namespace layout
+  {
+    struct XlibSurfaceCreateInfoKHR
+    {
+    protected:
+      XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(),
+                                Display* dpy_ = nullptr,
+                                Window window_ = 0 )
+        : flags( flags_ )
+        , dpy( dpy_ )
+        , window( window_ )
+      {}
+
+      XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this) = rhs;
+      }
+
+      XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
+      {
+        *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this) = rhs;
+        return *this;
+      }
+
+    public:
+      vk::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
+      const void* pNext = nullptr;
+      vk::XlibSurfaceCreateFlagsKHR flags;
+      Display* dpy;
+      Window window;
+    };
+    static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+  }
+
+  struct XlibSurfaceCreateInfoKHR : public layout::XlibSurfaceCreateInfoKHR
   {
-    XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(),
+    XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(),
                               Display* dpy_ = nullptr,
                               Window window_ = 0 )
-      : flags( flags_ )
-      , dpy( dpy_ )
-      , window( window_ )
+      : layout::XlibSurfaceCreateInfoKHR( flags_, dpy_, window_ )
     {}
 
     XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
-    {
-      *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this) = rhs;
-    }
+      : layout::XlibSurfaceCreateInfoKHR( rhs )
+    {}
 
     XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
     {
@@ -50081,7 +61958,7 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    XlibSurfaceCreateInfoKHR & setFlags( XlibSurfaceCreateFlagsKHR flags_ )
+    XlibSurfaceCreateInfoKHR & setFlags( vk::XlibSurfaceCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
@@ -50124,27 +62001,22 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    XlibSurfaceCreateFlagsKHR flags;
-    Display* dpy;
-    Window window;
+    using layout::XlibSurfaceCreateInfoKHR::sType;
   };
   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!" );
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d)
+  VULKAN_HPP_INLINE Result createInstance( const vk::InstanceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Instance* pInstance, Dispatch const &d)
   {
     return static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkInstance*>( pInstance ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
+  VULKAN_HPP_INLINE ResultValueType<vk::Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
   {
-    Instance instance;
+    vk::Instance instance;
     Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
     return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstance" );
   }
@@ -50152,7 +62024,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
   {
-    Instance instance;
+    vk::Instance instance;
     Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
 
     ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
@@ -50162,7 +62034,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d)
+  VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, vk::ExtensionProperties* pProperties, Dispatch const &d)
   {
     return static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
   }
@@ -50214,7 +62086,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d)
+  VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, vk::LayerProperties* pProperties, Dispatch const &d)
   {
     return static_cast<Result>( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
   }
@@ -50281,7 +62153,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result CommandBuffer::begin( const vk::CommandBufferBeginInfo* pBeginInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( pBeginInfo ) ) );
   }
@@ -50295,7 +62167,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const vk::ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d) const
   {
     d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( pConditionalRenderingBegin ) );
   }
@@ -50308,7 +62180,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
   {
     d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
   }
@@ -50322,13 +62194,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, Dispatch const &d) const
   {
     d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, Dispatch const &d ) const
   {
     d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
   }
@@ -50336,33 +62208,33 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, uint32_t index, Dispatch const &d) const
   {
     d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, uint32_t index, Dispatch const &d ) const
   {
     d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const vk::RenderPassBeginInfo* pRenderPassBegin, vk::SubpassContents contents, Dispatch const &d) const
   {
     d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, vk::SubpassContents contents, Dispatch const &d ) const
   {
     d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const vk::RenderPassBeginInfo* pRenderPassBegin, const vk::SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d) const
   {
     d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ) );
   }
@@ -50375,13 +62247,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer* pCounterBuffers, const vk::DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
   {
     d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), reinterpret_cast<const VkDeviceSize*>( pCounterBufferOffsets ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const vk::Buffer> counterBuffers, ArrayProxy<const vk::DeviceSize> counterBufferOffsets, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
@@ -50396,13 +62268,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d) const
   {
     d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, ArrayProxy<const vk::DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d ) const
   {
     d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ), dynamicOffsets.size() , dynamicOffsets.data() );
   }
@@ -50410,13 +62282,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( vk::Buffer buffer, vk::DeviceSize offset, vk::IndexType indexType, Dispatch const &d) const
   {
     d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkIndexType>( indexType ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( vk::Buffer buffer, vk::DeviceSize offset, vk::IndexType indexType, Dispatch const &d ) const
   {
     d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkIndexType>( indexType ) );
   }
@@ -50424,13 +62296,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d) const
   {
     d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d ) const
   {
     d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
   }
@@ -50438,26 +62310,26 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d) const
   {
     d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d ) const
   {
     d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer* pBuffers, const vk::DeviceSize* pOffsets, const vk::DeviceSize* pSizes, Dispatch const &d) const
   {
     d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), reinterpret_cast<const VkDeviceSize*>( pOffsets ), reinterpret_cast<const VkDeviceSize*>( pSizes ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const vk::Buffer> buffers, ArrayProxy<const vk::DeviceSize> offsets, ArrayProxy<const vk::DeviceSize> sizes, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
@@ -50488,13 +62360,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer* pBuffers, const vk::DeviceSize* pOffsets, Dispatch const &d) const
   {
     d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), reinterpret_cast<const VkDeviceSize*>( pOffsets ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const vk::Buffer> buffers, ArrayProxy<const vk::DeviceSize> offsets, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
@@ -50509,65 +62381,65 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::blitImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageBlit* pRegions, vk::Filter filter, Dispatch const &d) const
   {
     d.vkCmdBlitImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageBlit*>( pRegions ), static_cast<VkFilter>( filter ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::blitImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageBlit> regions, vk::Filter filter, Dispatch const &d ) const
   {
     d.vkCmdBlitImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageBlit*>( regions.data() ), static_cast<VkFilter>( filter ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const vk::AccelerationStructureInfoNV* pInfo, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d) const
   {
     d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( pInfo ), static_cast<VkBuffer>( instanceData ), static_cast<VkDeviceSize>( instanceOffset ), static_cast<VkBool32>( update ), static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), static_cast<VkDeviceSize>( scratchOffset ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d ) const
   {
     d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( &info ), static_cast<VkBuffer>( instanceData ), static_cast<VkDeviceSize>( instanceOffset ), static_cast<VkBool32>( update ), static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), static_cast<VkDeviceSize>( scratchOffset ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const vk::ClearAttachment* pAttachments, uint32_t rectCount, const vk::ClearRect* pRects, Dispatch const &d) const
   {
     d.vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast<const VkClearAttachment*>( pAttachments ), rectCount, reinterpret_cast<const VkClearRect*>( pRects ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const vk::ClearAttachment> attachments, ArrayProxy<const vk::ClearRect> rects, Dispatch const &d ) const
   {
     d.vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast<const VkClearAttachment*>( attachments.data() ), rects.size() , reinterpret_cast<const VkClearRect*>( rects.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( vk::Image image, vk::ImageLayout imageLayout, const vk::ClearColorValue* pColor, uint32_t rangeCount, const vk::ImageSubresourceRange* pRanges, Dispatch const &d) const
   {
     d.vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( pColor ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( vk::Image image, vk::ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const vk::ImageSubresourceRange> ranges, Dispatch const &d ) const
   {
     d.vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( &color ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( vk::Image image, vk::ImageLayout imageLayout, const vk::ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const vk::ImageSubresourceRange* pRanges, Dispatch const &d) const
   {
     d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( pDepthStencil ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( vk::Image image, vk::ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const vk::ImageSubresourceRange> ranges, Dispatch const &d ) const
   {
     d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( &depthStencil ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
   }
@@ -50575,65 +62447,65 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::CopyAccelerationStructureModeNV mode, Dispatch const &d) const
   {
     d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::CopyAccelerationStructureModeNV mode, Dispatch const &d ) const
   {
     d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( vk::Buffer srcBuffer, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferCopy* pRegions, Dispatch const &d) const
   {
     d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferCopy*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( vk::Buffer srcBuffer, vk::Buffer dstBuffer, ArrayProxy<const vk::BufferCopy> regions, Dispatch const &d ) const
   {
     d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferCopy*>( regions.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::BufferImageCopy* pRegions, Dispatch const &d) const
   {
     d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::BufferImageCopy> regions, Dispatch const &d ) const
   {
     d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageCopy* pRegions, Dispatch const &d) const
   {
     d.vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageCopy*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageCopy> regions, Dispatch const &d ) const
   {
     d.vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageCopy*>( regions.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferImageCopy* pRegions, Dispatch const &d) const
   {
     d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, ArrayProxy<const vk::BufferImageCopy> regions, Dispatch const &d ) const
   {
     d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
   }
@@ -50641,20 +62513,20 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d) const
   {
     d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d ) const
   {
     d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const vk::DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const
   {
     d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
   }
@@ -50681,7 +62553,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const vk::DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const
   {
     d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
   }
@@ -50737,13 +62609,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d) const
   {
     d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d ) const
   {
     d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
   }
@@ -50779,13 +62651,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
   {
     d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
   {
     d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
@@ -50793,13 +62665,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
     d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
     d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
@@ -50807,13 +62679,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
     d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
     d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
@@ -50821,13 +62693,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
   {
     d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
   {
     d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
@@ -50835,13 +62707,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, vk::Buffer counterBuffer, vk::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d) const
   {
     d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), static_cast<VkDeviceSize>( counterBufferOffset ), counterOffset, vertexStride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, vk::Buffer counterBuffer, vk::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d ) const
   {
     d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), static_cast<VkDeviceSize>( counterBufferOffset ), counterOffset, vertexStride );
   }
@@ -50849,13 +62721,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
     d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
     d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
@@ -50863,13 +62735,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
     d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
     d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
@@ -50877,13 +62749,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
     d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
     d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
@@ -50891,13 +62763,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
   {
     d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
   {
     d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
@@ -50947,13 +62819,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::endQuery( vk::QueryPool queryPool, uint32_t query, Dispatch const &d) const
   {
     d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::endQuery( vk::QueryPool queryPool, uint32_t query, Dispatch const &d ) const
   {
     d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
   }
@@ -50961,13 +62833,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const
   {
     d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d ) const
   {
     d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
   }
@@ -50988,7 +62860,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const vk::SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
   {
     d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
   }
@@ -51001,13 +62873,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer* pCounterBuffers, const vk::DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
   {
     d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), reinterpret_cast<const VkDeviceSize*>( pCounterBufferOffsets ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const vk::Buffer> counterBuffers, ArrayProxy<const vk::DeviceSize> counterBufferOffsets, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
@@ -51022,13 +62894,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
   {
     d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d ) const
   {
     d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
   }
@@ -51036,20 +62908,20 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize size, uint32_t data, Dispatch const &d) const
   {
     d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( size ), data );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize size, uint32_t data, Dispatch const &d ) const
   {
     d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( size ), data );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
   {
     d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
   }
@@ -51063,20 +62935,20 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( vk::SubpassContents contents, Dispatch const &d) const
   {
     d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( vk::SubpassContents contents, Dispatch const &d ) const
   {
     d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const vk::SubpassBeginInfoKHR* pSubpassBeginInfo, const vk::SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
   {
     d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
   }
@@ -51089,20 +62961,20 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const vk::MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
   {
     d.vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, ArrayProxy<const vk::MemoryBarrier> memoryBarriers, ArrayProxy<const vk::BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const vk::ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
   {
     d.vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const vk::CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const
   {
     d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( pProcessCommandsInfo ) );
   }
@@ -51115,26 +62987,26 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const
   {
     d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename T, typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d ) const
   {
     d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast<const void*>( values.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const vk::WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const
   {
     d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, ArrayProxy<const vk::WriteDescriptorSet> descriptorWrites, Dispatch const &d ) const
   {
     d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ) );
   }
@@ -51142,20 +63014,20 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const
   {
     d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const
   {
     d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const vk::CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d) const
   {
     d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( pReserveSpaceInfo ) );
   }
@@ -51169,13 +63041,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d) const
   {
     d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d ) const
   {
     d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
   }
@@ -51183,26 +63055,26 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
   {
     d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
   {
     d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageResolve* pRegions, Dispatch const &d) const
   {
     d.vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageResolve*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageResolve> regions, Dispatch const &d ) const
   {
     d.vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageResolve*>( regions.data() ) );
   }
@@ -51237,13 +63109,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( vk::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
   {
     d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrderCount, reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( pCustomSampleOrders ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( vk::CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const vk::CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d ) const
   {
     d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrders.size() , reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( customSampleOrders.data() ) );
   }
@@ -51306,13 +63178,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const vk::Rect2D* pDiscardRectangles, Dispatch const &d) const
   {
     d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D*>( pDiscardRectangles ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const vk::Rect2D> discardRectangles, Dispatch const &d ) const
   {
     d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast<const VkRect2D*>( discardRectangles.data() ) );
   }
@@ -51320,26 +63192,26 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d) const
   {
     d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d ) const
   {
     d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const vk::Rect2D* pExclusiveScissors, Dispatch const &d) const
   {
     d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D*>( pExclusiveScissors ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const vk::Rect2D> exclusiveScissors, Dispatch const &d ) const
   {
     d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size() , reinterpret_cast<const VkRect2D*>( exclusiveScissors.data() ) );
   }
@@ -51347,6 +63219,20 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d) const
+  {
+    d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d ) const
+  {
+    d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d) const
   {
     d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
@@ -51360,7 +63246,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const vk::PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL*>( pMarkerInfo ) ) );
   }
@@ -51374,7 +63260,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( const vk::PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL*>( pOverrideInfo ) ) );
   }
@@ -51388,7 +63274,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( const vk::PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL*>( pMarkerInfo ) ) );
   }
@@ -51402,7 +63288,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const vk::SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const
   {
     d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( pSampleLocationsInfo ) );
   }
@@ -51415,13 +63301,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const vk::Rect2D* pScissors, Dispatch const &d) const
   {
     d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>( pScissors ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const vk::Rect2D> scissors, Dispatch const &d ) const
   {
     d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast<const VkRect2D*>( scissors.data() ) );
   }
@@ -51429,13 +63315,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( vk::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const
   {
     d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( vk::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const
   {
     d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
   }
@@ -51443,13 +63329,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( vk::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d) const
   {
     d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( vk::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d ) const
   {
     d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
   }
@@ -51457,52 +63343,52 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( vk::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const
   {
     d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( vk::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const
   {
     d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const vk::Viewport* pViewports, Dispatch const &d) const
   {
     d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport*>( pViewports ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const vk::Viewport> viewports, Dispatch const &d ) const
   {
     d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast<const VkViewport*>( viewports.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const vk::ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
   {
     d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV*>( pShadingRatePalettes ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const vk::ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d ) const
   {
     d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, shadingRatePalettes.size() , reinterpret_cast<const VkShadingRatePaletteNV*>( shadingRatePalettes.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const vk::ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const
   {
     d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV*>( pViewportWScalings ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const vk::ViewportWScalingNV> viewportWScalings, Dispatch const &d ) const
   {
     d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast<const VkViewportWScalingNV*>( viewportWScalings.data() ) );
   }
@@ -51510,52 +63396,52 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( vk::Buffer raygenShaderBindingTableBuffer, vk::DeviceSize raygenShaderBindingOffset, vk::Buffer missShaderBindingTableBuffer, vk::DeviceSize missShaderBindingOffset, vk::DeviceSize missShaderBindingStride, vk::Buffer hitShaderBindingTableBuffer, vk::DeviceSize hitShaderBindingOffset, vk::DeviceSize hitShaderBindingStride, vk::Buffer callableShaderBindingTableBuffer, vk::DeviceSize callableShaderBindingOffset, vk::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const
   {
     d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), static_cast<VkDeviceSize>( raygenShaderBindingOffset ), static_cast<VkBuffer>( missShaderBindingTableBuffer ), static_cast<VkDeviceSize>( missShaderBindingOffset ), static_cast<VkDeviceSize>( missShaderBindingStride ), static_cast<VkBuffer>( hitShaderBindingTableBuffer ), static_cast<VkDeviceSize>( hitShaderBindingOffset ), static_cast<VkDeviceSize>( hitShaderBindingStride ), static_cast<VkBuffer>( callableShaderBindingTableBuffer ), static_cast<VkDeviceSize>( callableShaderBindingOffset ), static_cast<VkDeviceSize>( callableShaderBindingStride ), width, height, depth );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( vk::Buffer raygenShaderBindingTableBuffer, vk::DeviceSize raygenShaderBindingOffset, vk::Buffer missShaderBindingTableBuffer, vk::DeviceSize missShaderBindingOffset, vk::DeviceSize missShaderBindingStride, vk::Buffer hitShaderBindingTableBuffer, vk::DeviceSize hitShaderBindingOffset, vk::DeviceSize hitShaderBindingStride, vk::Buffer callableShaderBindingTableBuffer, vk::DeviceSize callableShaderBindingOffset, vk::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const
   {
     d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), static_cast<VkDeviceSize>( raygenShaderBindingOffset ), static_cast<VkBuffer>( missShaderBindingTableBuffer ), static_cast<VkDeviceSize>( missShaderBindingOffset ), static_cast<VkDeviceSize>( missShaderBindingStride ), static_cast<VkBuffer>( hitShaderBindingTableBuffer ), static_cast<VkDeviceSize>( hitShaderBindingOffset ), static_cast<VkDeviceSize>( hitShaderBindingStride ), static_cast<VkBuffer>( callableShaderBindingTableBuffer ), static_cast<VkDeviceSize>( callableShaderBindingOffset ), static_cast<VkDeviceSize>( callableShaderBindingStride ), width, height, depth );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize dataSize, const void* pData, Dispatch const &d) const
   {
     d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( dataSize ), pData );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename T, typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d ) const
   {
     d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), data.size() * sizeof( T ) , reinterpret_cast<const void*>( data.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const vk::Event* pEvents, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const vk::MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
   {
     d.vkCmdWaitEvents( m_commandBuffer, eventCount, reinterpret_cast<const VkEvent*>( pEvents ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const vk::Event> events, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, ArrayProxy<const vk::MemoryBarrier> memoryBarriers, ArrayProxy<const vk::BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const vk::ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
   {
     d.vkCmdWaitEvents( m_commandBuffer, events.size() , reinterpret_cast<const VkEvent*>( events.data() ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const vk::AccelerationStructureNV* pAccelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const
   {
     d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructureCount, reinterpret_cast<const VkAccelerationStructureNV*>( pAccelerationStructures ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy<const vk::AccelerationStructureNV> accelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const
   {
     d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructures.size() , reinterpret_cast<const VkAccelerationStructureNV*>( accelerationStructures.data() ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
   }
@@ -51563,13 +63449,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( vk::PipelineStageFlagBits pipelineStage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const
   {
     d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), marker );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( vk::PipelineStageFlagBits pipelineStage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const
   {
     d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), marker );
   }
@@ -51577,13 +63463,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( vk::PipelineStageFlagBits pipelineStage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d) const
   {
     d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( vk::PipelineStageFlagBits pipelineStage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d ) const
   {
     d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
   }
@@ -51606,13 +63492,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result CommandBuffer::reset( vk::CommandBufferResetFlags flags, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::reset( vk::CommandBufferResetFlags flags, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::reset" );
@@ -51622,13 +63508,13 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::acquireFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireFullScreenExclusiveModeEXT" );
@@ -51637,7 +63523,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const vk::AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR*>( pAcquireInfo ), pImageIndex ) );
   }
@@ -51652,13 +63538,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, uint32_t* pImageIndex, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, Dispatch const &d ) const
   {
     uint32_t imageIndex;
     Result result = static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) );
@@ -51667,22 +63553,22 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( const vk::PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, vk::PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( m_device, reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>( pAcquireInfo ), reinterpret_cast<VkPerformanceConfigurationINTEL*>( pConfiguration ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<PerformanceConfigurationINTEL>::type Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::PerformanceConfigurationINTEL>::type Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d ) const
   {
-    PerformanceConfigurationINTEL configuration;
+    vk::PerformanceConfigurationINTEL configuration;
     Result result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( m_device, reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>( &acquireInfo ), reinterpret_cast<VkPerformanceConfigurationINTEL*>( &configuration ) ) );
     return createResultValue( result, configuration, VULKAN_HPP_NAMESPACE_STRING"::Device::acquirePerformanceConfigurationINTEL" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) );
   }
@@ -51744,7 +63630,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const vk::DescriptorSetAllocateInfo* pAllocateInfo, vk::DescriptorSet* pDescriptorSets, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet*>( pDescriptorSets ) ) );
   }
@@ -51806,15 +63692,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::allocateMemory( const vk::MemoryAllocateInfo* pAllocateInfo, const vk::AllocationCallbacks* pAllocator, vk::DeviceMemory* pMemory, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( pAllocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDeviceMemory*>( pMemory ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DeviceMemory>::type Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DeviceMemory>::type Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DeviceMemory memory;
+    vk::DeviceMemory memory;
     Result result = static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
     return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateMemory" );
   }
@@ -51822,7 +63708,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DeviceMemory,Dispatch>>::type Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DeviceMemory memory;
+    vk::DeviceMemory memory;
     Result result = static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
 
     ObjectFree<Device,Dispatch> deleter( *this, allocator, d );
@@ -51832,13 +63718,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const vk::BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( pBindInfos ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const vk::BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( bindInfos.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" );
@@ -51847,13 +63733,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::bindBufferMemory( vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory( vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory" );
@@ -51861,13 +63747,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, const vk::BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2( ArrayProxy<const vk::BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2" );
@@ -51875,13 +63761,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const vk::BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2KHR( ArrayProxy<const vk::BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2KHR" );
@@ -51890,13 +63776,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::bindImageMemory( vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory( vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory" );
@@ -51904,13 +63790,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, const vk::BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2( ArrayProxy<const vk::BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2" );
@@ -51918,13 +63804,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const vk::BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2KHR( ArrayProxy<const vk::BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2KHR" );
@@ -51933,13 +63819,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::compileDeferredNV( vk::Pipeline pipeline, uint32_t shader, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::compileDeferredNV( vk::Pipeline pipeline, uint32_t shader, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNV" );
@@ -51947,15 +63833,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const vk::AccelerationStructureCreateInfoNV* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkAccelerationStructureNV*>( pAccelerationStructure ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<AccelerationStructureNV>::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::AccelerationStructureNV>::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    AccelerationStructureNV accelerationStructure;
+    vk::AccelerationStructureNV accelerationStructure;
     Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
     return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNV" );
   }
@@ -51963,7 +63849,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    AccelerationStructureNV accelerationStructure;
+    vk::AccelerationStructureNV accelerationStructure;
     Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51973,15 +63859,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createBuffer( const vk::BufferCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Buffer* pBuffer, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBuffer*>( pBuffer ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Buffer>::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Buffer>::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Buffer buffer;
+    vk::Buffer buffer;
     Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
     return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBuffer" );
   }
@@ -51989,7 +63875,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Buffer buffer;
+    vk::Buffer buffer;
     Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51999,15 +63885,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createBufferView( const vk::BufferViewCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::BufferView* pView, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBufferView*>( pView ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<BufferView>::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::BufferView>::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    BufferView view;
+    vk::BufferView view;
     Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
     return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferView" );
   }
@@ -52015,7 +63901,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    BufferView view;
+    vk::BufferView view;
     Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52025,15 +63911,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createCommandPool( const vk::CommandPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::CommandPool* pCommandPool, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkCommandPool*>( pCommandPool ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<CommandPool>::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::CommandPool>::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    CommandPool commandPool;
+    vk::CommandPool commandPool;
     Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
     return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPool" );
   }
@@ -52041,7 +63927,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    CommandPool commandPool;
+    vk::CommandPool commandPool;
     Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52051,27 +63937,27 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createComputePipelines( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::ComputePipelineCreateInfo* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
     Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
     Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
   }
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( vk::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     Pipeline pipeline;
     Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
@@ -52079,7 +63965,7 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
     std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
@@ -52098,7 +63984,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
     std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
@@ -52117,7 +64003,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
   }
   template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createComputePipelineUnique( vk::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     Pipeline pipeline;
     Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
@@ -52129,15 +64015,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createDescriptorPool( const vk::DescriptorPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorPool* pDescriptorPool, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorPool*>( pDescriptorPool ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DescriptorPool>::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DescriptorPool>::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DescriptorPool descriptorPool;
+    vk::DescriptorPool descriptorPool;
     Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
     return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPool" );
   }
@@ -52145,7 +64031,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DescriptorPool descriptorPool;
+    vk::DescriptorPool descriptorPool;
     Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52155,15 +64041,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorSetLayout* pSetLayout, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorSetLayout*>( pSetLayout ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DescriptorSetLayout>::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DescriptorSetLayout>::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DescriptorSetLayout setLayout;
+    vk::DescriptorSetLayout setLayout;
     Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
     return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayout" );
   }
@@ -52171,7 +64057,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DescriptorSetLayout setLayout;
+    vk::DescriptorSetLayout setLayout;
     Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52181,15 +64067,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const vk::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DescriptorUpdateTemplate descriptorUpdateTemplate;
+    vk::DescriptorUpdateTemplate descriptorUpdateTemplate;
     Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
     return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplate" );
   }
@@ -52197,7 +64083,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type Device::createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DescriptorUpdateTemplate descriptorUpdateTemplate;
+    vk::DescriptorUpdateTemplate descriptorUpdateTemplate;
     Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52207,15 +64093,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const vk::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DescriptorUpdateTemplate descriptorUpdateTemplate;
+    vk::DescriptorUpdateTemplate descriptorUpdateTemplate;
     Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
     return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHR" );
   }
@@ -52223,7 +64109,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DescriptorUpdateTemplate descriptorUpdateTemplate;
+    vk::DescriptorUpdateTemplate descriptorUpdateTemplate;
     Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52233,15 +64119,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createEvent( const vk::EventCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Event* pEvent, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkEvent*>( pEvent ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Event>::type Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Event>::type Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Event event;
+    vk::Event event;
     Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
     return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEvent" );
   }
@@ -52249,7 +64135,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Event,Dispatch>>::type Device::createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Event event;
+    vk::Event event;
     Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52259,15 +64145,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createFence( const vk::FenceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Fence>::type Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Fence fence;
+    vk::Fence fence;
     Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
     return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFence" );
   }
@@ -52275,7 +64161,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Fence fence;
+    vk::Fence fence;
     Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52285,15 +64171,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createFramebuffer( const vk::FramebufferCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Framebuffer* pFramebuffer, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFramebuffer*>( pFramebuffer ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Framebuffer>::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Framebuffer>::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Framebuffer framebuffer;
+    vk::Framebuffer framebuffer;
     Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
     return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebuffer" );
   }
@@ -52301,7 +64187,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Framebuffer framebuffer;
+    vk::Framebuffer framebuffer;
     Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52311,27 +64197,27 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::GraphicsPipelineCreateInfo* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
     Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
     Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
   }
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( vk::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     Pipeline pipeline;
     Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
@@ -52339,7 +64225,7 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
     std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
@@ -52358,7 +64244,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
     std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
@@ -52377,7 +64263,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
   }
   template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createGraphicsPipelineUnique( vk::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     Pipeline pipeline;
     Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
@@ -52389,15 +64275,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createImage( const vk::ImageCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Image* pImage, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImage*>( pImage ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Image>::type Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Image>::type Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Image image;
+    vk::Image image;
     Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
     return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImage" );
   }
@@ -52405,7 +64291,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Image,Dispatch>>::type Device::createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Image image;
+    vk::Image image;
     Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52415,15 +64301,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createImageView( const vk::ImageViewCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ImageView* pView, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImageView*>( pView ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageView>::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ImageView>::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ImageView view;
+    vk::ImageView view;
     Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
     return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageView" );
   }
@@ -52431,7 +64317,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ImageView view;
+    vk::ImageView view;
     Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52441,15 +64327,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const vk::IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( pIndirectCommandsLayout ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<IndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::IndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
+    vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
     Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
     return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVX" );
   }
@@ -52457,7 +64343,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type Device::createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
+    vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
     Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52467,15 +64353,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const vk::ObjectTableCreateInfoNVX* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ObjectTableNVX* pObjectTable, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkObjectTableNVX*>( pObjectTable ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ObjectTableNVX>::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ObjectTableNVX>::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ObjectTableNVX objectTable;
+    vk::ObjectTableNVX objectTable;
     Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
     return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVX" );
   }
@@ -52483,7 +64369,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type Device::createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ObjectTableNVX objectTable;
+    vk::ObjectTableNVX objectTable;
     Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52493,15 +64379,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createPipelineCache( const vk::PipelineCacheCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::PipelineCache* pPipelineCache, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineCache*>( pPipelineCache ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<PipelineCache>::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::PipelineCache>::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    PipelineCache pipelineCache;
+    vk::PipelineCache pipelineCache;
     Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
     return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCache" );
   }
@@ -52509,7 +64395,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    PipelineCache pipelineCache;
+    vk::PipelineCache pipelineCache;
     Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52519,15 +64405,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createPipelineLayout( const vk::PipelineLayoutCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::PipelineLayout* pPipelineLayout, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineLayout*>( pPipelineLayout ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<PipelineLayout>::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::PipelineLayout>::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    PipelineLayout pipelineLayout;
+    vk::PipelineLayout pipelineLayout;
     Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
     return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayout" );
   }
@@ -52535,7 +64421,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    PipelineLayout pipelineLayout;
+    vk::PipelineLayout pipelineLayout;
     Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52545,15 +64431,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createQueryPool( const vk::QueryPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::QueryPool* pQueryPool, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkQueryPool*>( pQueryPool ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<QueryPool>::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::QueryPool>::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    QueryPool queryPool;
+    vk::QueryPool queryPool;
     Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
     return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPool" );
   }
@@ -52561,7 +64447,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    QueryPool queryPool;
+    vk::QueryPool queryPool;
     Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52571,27 +64457,27 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::RayTracingPipelineCreateInfoNV* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
     Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
     Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
   }
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createRayTracingPipelineNV( vk::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     Pipeline pipeline;
     Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
@@ -52599,7 +64485,7 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
     std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
@@ -52618,7 +64504,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
     std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
@@ -52637,7 +64523,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
   }
   template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createRayTracingPipelineNVUnique( vk::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     Pipeline pipeline;
     Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
@@ -52649,15 +64535,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createRenderPass( const vk::RenderPassCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::RenderPass* pRenderPass, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::RenderPass>::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    RenderPass renderPass;
+    vk::RenderPass renderPass;
     Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
     return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass" );
   }
@@ -52665,7 +64551,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    RenderPass renderPass;
+    vk::RenderPass renderPass;
     Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52675,15 +64561,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const vk::RenderPassCreateInfo2KHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::RenderPass* pRenderPass, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::RenderPass>::type Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    RenderPass renderPass;
+    vk::RenderPass renderPass;
     Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
     return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHR" );
   }
@@ -52691,7 +64577,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    RenderPass renderPass;
+    vk::RenderPass renderPass;
     Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52701,15 +64587,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createSampler( const vk::SamplerCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Sampler* pSampler, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSampler*>( pSampler ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Sampler>::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Sampler>::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Sampler sampler;
+    vk::Sampler sampler;
     Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
     return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSampler" );
   }
@@ -52717,7 +64603,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Sampler sampler;
+    vk::Sampler sampler;
     Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52727,15 +64613,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const vk::SamplerYcbcrConversionCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SamplerYcbcrConversion ycbcrConversion;
+    vk::SamplerYcbcrConversion ycbcrConversion;
     Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
     return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversion" );
   }
@@ -52743,7 +64629,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SamplerYcbcrConversion ycbcrConversion;
+    vk::SamplerYcbcrConversion ycbcrConversion;
     Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52753,15 +64639,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const vk::SamplerYcbcrConversionCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SamplerYcbcrConversion ycbcrConversion;
+    vk::SamplerYcbcrConversion ycbcrConversion;
     Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
     return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHR" );
   }
@@ -52769,7 +64655,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SamplerYcbcrConversion ycbcrConversion;
+    vk::SamplerYcbcrConversion ycbcrConversion;
     Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52779,15 +64665,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createSemaphore( const vk::SemaphoreCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Semaphore* pSemaphore, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSemaphore*>( pSemaphore ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Semaphore>::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Semaphore>::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Semaphore semaphore;
+    vk::Semaphore semaphore;
     Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
     return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphore" );
   }
@@ -52795,7 +64681,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Semaphore semaphore;
+    vk::Semaphore semaphore;
     Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52805,15 +64691,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createShaderModule( const vk::ShaderModuleCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ShaderModule* pShaderModule, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkShaderModule*>( pShaderModule ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ShaderModule>::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ShaderModule>::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ShaderModule shaderModule;
+    vk::ShaderModule shaderModule;
     Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
     return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModule" );
   }
@@ -52821,7 +64707,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ShaderModule shaderModule;
+    vk::ShaderModule shaderModule;
     Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52831,20 +64717,20 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const vk::SwapchainCreateInfoKHR* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::SwapchainKHR* pSwapchains, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchains ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() );
     Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
     return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size(), vectorAllocator );
     Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
@@ -52859,7 +64745,7 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
     std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs;
@@ -52878,7 +64764,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
     std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs( vectorAllocator );
@@ -52909,15 +64795,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const vk::SwapchainCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SwapchainKHR* pSwapchain, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchain ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SwapchainKHR>::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SwapchainKHR swapchain;
+    vk::SwapchainKHR swapchain;
     Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
     return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHR" );
   }
@@ -52925,7 +64811,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SwapchainKHR swapchain;
+    vk::SwapchainKHR swapchain;
     Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52935,15 +64821,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const vk::ValidationCacheCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ValidationCacheEXT* pValidationCache, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkValidationCacheEXT*>( pValidationCache ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ValidationCacheEXT>::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ValidationCacheEXT>::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ValidationCacheEXT validationCache;
+    vk::ValidationCacheEXT validationCache;
     Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
     return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXT" );
   }
@@ -52951,7 +64837,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ValidationCacheEXT validationCache;
+    vk::ValidationCacheEXT validationCache;
     Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
 
     ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52961,7 +64847,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const vk::DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( pNameInfo ) ) );
   }
@@ -52975,7 +64861,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const vk::DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( pTagInfo ) ) );
   }
@@ -52989,202 +64875,202 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( vk::AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyBuffer( vk::Buffer buffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyBuffer( vk::Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Buffer buffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyBufferView( vk::BufferView bufferView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyBufferView( vk::BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::BufferView bufferView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyCommandPool( vk::CommandPool commandPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyCommandPool( vk::CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::CommandPool commandPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( vk::DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
@@ -53197,481 +65083,481 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyEvent( vk::Event event, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyEvent( vk::Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Event event, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyFence( vk::Fence fence, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyFence( vk::Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Fence fence, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyFramebuffer( vk::Framebuffer framebuffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyFramebuffer( vk::Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Framebuffer framebuffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyImage( vk::Image image, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyImage( vk::Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Image image, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyImageView( vk::ImageView imageView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyImageView( vk::ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::ImageView imageView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( vk::ObjectTableNVX objectTable, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( vk::ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::ObjectTableNVX objectTable, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyPipeline( vk::Pipeline pipeline, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyPipeline( vk::Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Pipeline pipeline, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyPipelineCache( vk::PipelineCache pipelineCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyPipelineCache( vk::PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::PipelineCache pipelineCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( vk::PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyQueryPool( vk::QueryPool queryPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyQueryPool( vk::QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::QueryPool queryPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyRenderPass( vk::RenderPass renderPass, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyRenderPass( vk::RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::RenderPass renderPass, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroySampler( vk::Sampler sampler, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroySampler( vk::Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Sampler sampler, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroySemaphore( vk::Semaphore semaphore, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroySemaphore( vk::Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Semaphore semaphore, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyShaderModule( vk::ShaderModule shaderModule, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyShaderModule( vk::ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::ShaderModule shaderModule, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( vk::SwapchainKHR swapchain, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( vk::SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::SwapchainKHR swapchain, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( vk::ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( vk::ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
@@ -53693,13 +65579,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( vk::DisplayKHR display, const vk::DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( pDisplayPowerInfo ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::displayPowerControlEXT( vk::DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( &displayPowerInfo ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::displayPowerControlEXT" );
@@ -53707,13 +65593,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const vk::MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::flushMappedMemoryRanges( ArrayProxy<const vk::MappedMemoryRange> memoryRanges, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::flushMappedMemoryRanges" );
@@ -53721,39 +65607,39 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::freeCommandBuffers( vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
   {
     d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::freeCommandBuffers( vk::CommandPool commandPool, ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d ) const
   {
     d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::free( vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
   {
     d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::free( vk::CommandPool commandPool, ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d ) const
   {
     d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::freeDescriptorSets( vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::freeDescriptorSets( vk::DescriptorPool descriptorPool, ArrayProxy<const vk::DescriptorSet> descriptorSets, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::freeDescriptorSets" );
@@ -53761,13 +65647,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::free( vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::free( vk::DescriptorPool descriptorPool, ArrayProxy<const vk::DescriptorSet> descriptorSets, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::free" );
@@ -53775,39 +65661,39 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::freeMemory( vk::DeviceMemory memory, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::freeMemory( vk::DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::free( vk::DeviceMemory memory, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::free( vk::DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( vk::AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename T, typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::getAccelerationStructureHandleNV( vk::AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" );
@@ -53815,15 +65701,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const vk::AccelerationStructureMemoryRequirementsInfoNV* pInfo, vk::MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
   {
-    MemoryRequirements2KHR memoryRequirements;
+    vk::MemoryRequirements2KHR memoryRequirements;
     d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
     return memoryRequirements;
   }
@@ -53831,7 +65717,7 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2KHR& memoryRequirements = structureChain.template get<MemoryRequirements2KHR>();
+    vk::MemoryRequirements2KHR& memoryRequirements = structureChain.template get<vk::MemoryRequirements2KHR>();
     d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
     return structureChain;
   }
@@ -53839,15 +65725,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, vk::AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( pProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::AndroidHardwareBufferPropertiesANDROID>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
   {
-    AndroidHardwareBufferPropertiesANDROID properties;
+    vk::AndroidHardwareBufferPropertiesANDROID properties;
     Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
     return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
   }
@@ -53855,7 +65741,7 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<AndroidHardwareBufferPropertiesANDROID>();
+    vk::AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<vk::AndroidHardwareBufferPropertiesANDROID>();
     Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
     return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
   }
@@ -53863,7 +65749,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const vk::BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d) const
   {
     return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfoEXT*>( pInfo ) ) );
   }
@@ -53876,30 +65762,30 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( vk::Buffer buffer, vk::MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::MemoryRequirements Device::getBufferMemoryRequirements( vk::Buffer buffer, Dispatch const &d ) const
   {
-    MemoryRequirements memoryRequirements;
+    vk::MemoryRequirements memoryRequirements;
     d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
     return memoryRequirements;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const vk::BufferMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
-    MemoryRequirements2 memoryRequirements;
+    vk::MemoryRequirements2 memoryRequirements;
     d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return memoryRequirements;
   }
@@ -53907,22 +65793,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+    vk::MemoryRequirements2& memoryRequirements = structureChain.template get<vk::MemoryRequirements2>();
     d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const vk::BufferMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
-    MemoryRequirements2 memoryRequirements;
+    vk::MemoryRequirements2 memoryRequirements;
     d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return memoryRequirements;
   }
@@ -53930,20 +65816,20 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+    vk::MemoryRequirements2& memoryRequirements = structureChain.template get<vk::MemoryRequirements2>();
     d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const vk::CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT( ArrayProxy<const vk::CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
@@ -53960,15 +65846,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, vk::DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const
   {
     d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
   {
-    DescriptorSetLayoutSupport support;
+    vk::DescriptorSetLayoutSupport support;
     d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return support;
   }
@@ -53976,22 +65862,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
+    vk::DescriptorSetLayoutSupport& support = structureChain.template get<vk::DescriptorSetLayoutSupport>();
     d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, vk::DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const
   {
     d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
   {
-    DescriptorSetLayoutSupport support;
+    vk::DescriptorSetLayoutSupport support;
     d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return support;
   }
@@ -53999,52 +65885,52 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
+    vk::DescriptorSetLayoutSupport& support = structureChain.template get<vk::DescriptorSetLayoutSupport>();
     d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
   {
     d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
   {
-    PeerMemoryFeatureFlags peerMemoryFeatures;
+    vk::PeerMemoryFeatureFlags peerMemoryFeatures;
     d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
     return peerMemoryFeatures;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
   {
     d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
   {
-    PeerMemoryFeatureFlags peerMemoryFeatures;
+    vk::PeerMemoryFeatureFlags peerMemoryFeatures;
     d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
     return peerMemoryFeatures;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( vk::DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( pDeviceGroupPresentCapabilities ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type Device::getGroupPresentCapabilitiesKHR(Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DeviceGroupPresentCapabilitiesKHR>::type Device::getGroupPresentCapabilitiesKHR(Dispatch const &d ) const
   {
-    DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
+    vk::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
     Result result = static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( &deviceGroupPresentCapabilities ) ) );
     return createResultValue( result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupPresentCapabilitiesKHR" );
   }
@@ -54052,15 +65938,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, vk::DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( pModes ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
   {
-    DeviceGroupPresentModeFlagsKHR modes;
+    vk::DeviceGroupPresentModeFlagsKHR modes;
     Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( &modes ) ) );
     return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModes2EXT" );
   }
@@ -54068,30 +65954,30 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( vk::SurfaceKHR surface, vk::DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( pModes ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModesKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
   {
-    DeviceGroupPresentModeFlagsKHR modes;
+    vk::DeviceGroupPresentModeFlagsKHR modes;
     Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( &modes ) ) );
     return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModesKHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getMemoryCommitment( vk::DeviceMemory memory, vk::DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const
   {
     d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize*>( pCommittedMemoryInBytes ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::DeviceSize Device::getMemoryCommitment( vk::DeviceMemory memory, Dispatch const &d ) const
   {
-    DeviceSize committedMemoryInBytes;
+    vk::DeviceSize committedMemoryInBytes;
     d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize*>( &committedMemoryInBytes ) );
     return committedMemoryInBytes;
   }
@@ -54111,30 +65997,30 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, vk::Queue* pQueue, Dispatch const &d) const
   {
     d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( pQueue ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const
   {
-    Queue queue;
+    vk::Queue queue;
     d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( &queue ) );
     return queue;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getQueue2( const vk::DeviceQueueInfo2* pQueueInfo, vk::Queue* pQueue, Dispatch const &d) const
   {
     d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( pQueueInfo ), reinterpret_cast<VkQueue*>( pQueue ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const
   {
-    Queue queue;
+    vk::Queue queue;
     d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( &queueInfo ), reinterpret_cast<VkQueue*>( &queue ) );
     return queue;
   }
@@ -54142,13 +66028,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getEventStatus( vk::Event event, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d ) const
+  VULKAN_HPP_INLINE Result Device::getEventStatus( vk::Event event, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } );
@@ -54156,7 +66042,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const vk::FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
   }
@@ -54172,13 +66058,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getFenceStatus( vk::Fence fence, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d ) const
+  VULKAN_HPP_INLINE Result Device::getFenceStatus( vk::Fence fence, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } );
@@ -54187,7 +66073,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const vk::FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
   }
@@ -54203,45 +66089,45 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( vk::Image image, vk::ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( pProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ImageDrmFormatModifierPropertiesEXT>::type Device::getImageDrmFormatModifierPropertiesEXT( vk::Image image, Dispatch const &d ) const
   {
-    ImageDrmFormatModifierPropertiesEXT properties;
+    vk::ImageDrmFormatModifierPropertiesEXT properties;
     Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( &properties ) ) );
     return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getImageDrmFormatModifierPropertiesEXT" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( vk::Image image, vk::MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::MemoryRequirements Device::getImageMemoryRequirements( vk::Image image, Dispatch const &d ) const
   {
-    MemoryRequirements memoryRequirements;
+    vk::MemoryRequirements memoryRequirements;
     d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
     return memoryRequirements;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const vk::ImageMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
-    MemoryRequirements2 memoryRequirements;
+    vk::MemoryRequirements2 memoryRequirements;
     d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return memoryRequirements;
   }
@@ -54249,22 +66135,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+    vk::MemoryRequirements2& memoryRequirements = structureChain.template get<vk::MemoryRequirements2>();
     d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const vk::ImageMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
-    MemoryRequirements2 memoryRequirements;
+    vk::MemoryRequirements2 memoryRequirements;
     d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return memoryRequirements;
   }
@@ -54272,20 +66158,20 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+    vk::MemoryRequirements2& memoryRequirements = structureChain.template get<vk::MemoryRequirements2>();
     d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( vk::Image image, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( pSparseMemoryRequirements ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Dispatch const &d ) const
+  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( vk::Image image, Dispatch const &d ) const
   {
     std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements;
     uint32_t sparseMemoryRequirementCount;
@@ -54295,7 +66181,7 @@ namespace VULKAN_HPP_NAMESPACE
     return sparseMemoryRequirements;
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( vk::Image image, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements( vectorAllocator );
     uint32_t sparseMemoryRequirementCount;
@@ -54307,7 +66193,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const vk::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
   }
@@ -54335,7 +66221,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const vk::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
   {
     d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
   }
@@ -54363,22 +66249,22 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( vk::Image image, const vk::ImageSubresource* pSubresource, vk::SubresourceLayout* pLayout, Dispatch const &d) const
   {
     d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( pSubresource ), reinterpret_cast<VkSubresourceLayout*>( pLayout ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::SubresourceLayout Device::getImageSubresourceLayout( vk::Image image, const ImageSubresource & subresource, Dispatch const &d ) const
   {
-    SubresourceLayout layout;
+    vk::SubresourceLayout layout;
     d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( &subresource ), reinterpret_cast<VkSubresourceLayout*>( &layout ) );
     return layout;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX* pInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const vk::ImageViewHandleInfoNVX* pInfo, Dispatch const &d) const
   {
     return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX*>( pInfo ) );
   }
@@ -54392,7 +66278,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const vk::MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( pInfo ), pBuffer ) );
   }
@@ -54408,7 +66294,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const vk::MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
   }
@@ -54423,30 +66309,30 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, vk::MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( pMemoryFdProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<MemoryFdPropertiesKHR>::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::MemoryFdPropertiesKHR>::type Device::getMemoryFdPropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d ) const
   {
-    MemoryFdPropertiesKHR memoryFdProperties;
+    vk::MemoryFdPropertiesKHR memoryFdProperties;
     Result result = static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( &memoryFdProperties ) ) );
     return createResultValue( result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdPropertiesKHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( vk::ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, vk::MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( pMemoryHostPointerProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( vk::ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d ) const
   {
-    MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
+    vk::MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
     Result result = static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( &memoryHostPointerProperties ) ) );
     return createResultValue( result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryHostPointerPropertiesEXT" );
   }
@@ -54454,7 +66340,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const vk::MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
   }
@@ -54471,13 +66357,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( vk::DeviceMemory memory, vk::ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( vk::DeviceMemory memory, vk::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const
   {
     HANDLE handle;
     Result result = static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
@@ -54488,15 +66374,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, vk::MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( pMemoryWin32HandleProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const
   {
-    MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
+    vk::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
     Result result = static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( &memoryWin32HandleProperties ) ) );
     return createResultValue( result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandlePropertiesKHR" );
   }
@@ -54504,13 +66390,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, vk::PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), pPresentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( pPresentationTimings ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, Dispatch const &d ) const
   {
     std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings;
     uint32_t presentationTimingCount;
@@ -54532,7 +66418,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings( vectorAllocator );
     uint32_t presentationTimingCount;
@@ -54556,28 +66442,28 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, PerformanceValueINTEL* pValue, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( vk::PerformanceParameterTypeINTEL parameter, vk::PerformanceValueINTEL* pValue, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPerformanceParameterINTEL( m_device, static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL*>( pValue ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<PerformanceValueINTEL>::type Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::PerformanceValueINTEL>::type Device::getPerformanceParameterINTEL( vk::PerformanceParameterTypeINTEL parameter, Dispatch const &d ) const
   {
-    PerformanceValueINTEL value;
+    vk::PerformanceValueINTEL value;
     Result result = static_cast<Result>( d.vkGetPerformanceParameterINTEL( m_device, static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL*>( &value ) ) );
     return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING"::Device::getPerformanceParameterINTEL" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getPipelineCacheData( vk::PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( vk::PipelineCache pipelineCache, Dispatch const &d ) const
   {
     std::vector<uint8_t,Allocator> data;
     size_t dataSize;
@@ -54599,7 +66485,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( vk::PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<uint8_t,Allocator> data( vectorAllocator );
     size_t dataSize;
@@ -54623,13 +66509,169 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getPipelineExecutableInternalRepresentationsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, vk::PipelineExecutableInternalRepresentationKHR* pInternalRepresentations, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( pExecutableInfo ), pInternalRepresentationCount, reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( pInternalRepresentations ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,Allocator>>::type Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d ) const
+  {
+    std::vector<PipelineExecutableInternalRepresentationKHR,Allocator> internalRepresentations;
+    uint32_t internalRepresentationCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &internalRepresentationCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && internalRepresentationCount )
+      {
+        internalRepresentations.resize( internalRepresentationCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &internalRepresentationCount, reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( internalRepresentations.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
+      internalRepresentations.resize( internalRepresentationCount );
+    }
+    return createResultValue( result, internalRepresentations, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableInternalRepresentationsKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,Allocator>>::type Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<PipelineExecutableInternalRepresentationKHR,Allocator> internalRepresentations( vectorAllocator );
+    uint32_t internalRepresentationCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &internalRepresentationCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && internalRepresentationCount )
+      {
+        internalRepresentations.resize( internalRepresentationCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &internalRepresentationCount, reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( internalRepresentations.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
+      internalRepresentations.resize( internalRepresentationCount );
+    }
+    return createResultValue( result, internalRepresentations, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableInternalRepresentationsKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getPipelineExecutablePropertiesKHR( const vk::PipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, vk::PipelineExecutablePropertiesKHR* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( pPipelineInfo ), pExecutableCount, reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR,Allocator>>::type Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const &d ) const
+  {
+    std::vector<PipelineExecutablePropertiesKHR,Allocator> properties;
+    uint32_t executableCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( &pipelineInfo ), &executableCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && executableCount )
+      {
+        properties.resize( executableCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( &pipelineInfo ), &executableCount, reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( executableCount <= properties.size() );
+      properties.resize( executableCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutablePropertiesKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR,Allocator>>::type Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<PipelineExecutablePropertiesKHR,Allocator> properties( vectorAllocator );
+    uint32_t executableCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( &pipelineInfo ), &executableCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && executableCount )
+      {
+        properties.resize( executableCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( &pipelineInfo ), &executableCount, reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( executableCount <= properties.size() );
+      properties.resize( executableCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutablePropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getPipelineExecutableStatisticsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, vk::PipelineExecutableStatisticKHR* pStatistics, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( pExecutableInfo ), pStatisticCount, reinterpret_cast<VkPipelineExecutableStatisticKHR*>( pStatistics ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableStatisticKHR,Allocator>>::type Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d ) const
+  {
+    std::vector<PipelineExecutableStatisticKHR,Allocator> statistics;
+    uint32_t statisticCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &statisticCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && statisticCount )
+      {
+        statistics.resize( statisticCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &statisticCount, reinterpret_cast<VkPipelineExecutableStatisticKHR*>( statistics.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
+      statistics.resize( statisticCount );
+    }
+    return createResultValue( result, statistics, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableStatisticsKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableStatisticKHR,Allocator>>::type Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<PipelineExecutableStatisticKHR,Allocator> statistics( vectorAllocator );
+    uint32_t statisticCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &statisticCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && statisticCount )
+      {
+        statistics.resize( statisticCount );
+        result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &statisticCount, reinterpret_cast<VkPipelineExecutableStatisticKHR*>( statistics.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
+      statistics.resize( statisticCount );
+    }
+    return createResultValue( result, statistics, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableStatisticsKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename T, typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
@@ -54637,13 +66679,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename T, typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
@@ -54651,37 +66693,37 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( vk::SwapchainKHR swapchain, vk::RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( pDisplayTimingProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<RefreshCycleDurationGOOGLE>::type Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::RefreshCycleDurationGOOGLE>::type Device::getRefreshCycleDurationGOOGLE( vk::SwapchainKHR swapchain, Dispatch const &d ) const
   {
-    RefreshCycleDurationGOOGLE displayTimingProperties;
+    vk::RefreshCycleDurationGOOGLE displayTimingProperties;
     Result result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( &displayTimingProperties ) ) );
     return createResultValue( result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getRefreshCycleDurationGOOGLE" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( vk::RenderPass renderPass, vk::Extent2D* pGranularity, Dispatch const &d) const
   {
     d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( pGranularity ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::Extent2D Device::getRenderAreaGranularity( vk::RenderPass renderPass, Dispatch const &d ) const
   {
-    Extent2D granularity;
+    vk::Extent2D granularity;
     d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( &granularity ) );
     return granularity;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const vk::SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
   }
@@ -54697,7 +66739,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const vk::SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
   }
@@ -54713,13 +66755,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), pInfoSize, pInfo ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Dispatch const &d ) const
   {
     std::vector<uint8_t,Allocator> info;
     size_t infoSize;
@@ -54741,7 +66783,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<uint8_t,Allocator> info( vectorAllocator );
     size_t infoSize;
@@ -54765,13 +66807,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getSwapchainCounterEXT( vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, Dispatch const &d ) const
   {
     uint64_t counterValue;
     Result result = static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
@@ -54780,13 +66822,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( vk::SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, vk::Image* pSwapchainImages, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage*>( pSwapchainImages ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( vk::SwapchainKHR swapchain, Dispatch const &d ) const
   {
     std::vector<Image,Allocator> swapchainImages;
     uint32_t swapchainImageCount;
@@ -54808,7 +66850,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( vk::SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<Image,Allocator> swapchainImages( vectorAllocator );
     uint32_t swapchainImageCount;
@@ -54833,13 +66875,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( vk::SwapchainKHR swapchain, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d ) const
+  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( vk::SwapchainKHR swapchain, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
@@ -54847,13 +66889,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, Dispatch const &d ) const
   {
     std::vector<uint8_t,Allocator> data;
     size_t dataSize;
@@ -54875,7 +66917,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<uint8_t,Allocator> data( vectorAllocator );
     size_t dataSize;
@@ -54899,7 +66941,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const vk::ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( pImportFenceFdInfo ) ) );
   }
@@ -54914,7 +66956,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const vk::ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( pImportFenceWin32HandleInfo ) ) );
   }
@@ -54929,7 +66971,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const vk::ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( pImportSemaphoreFdInfo ) ) );
   }
@@ -54944,7 +66986,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const vk::ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( pImportSemaphoreWin32HandleInfo ) ) );
   }
@@ -54959,7 +67001,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( const vk::InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL*>( pInitializeInfo ) ) );
   }
@@ -54973,13 +67015,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const vk::MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::invalidateMappedMemoryRanges( ArrayProxy<const vk::MappedMemoryRange> memoryRanges, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::invalidateMappedMemoryRanges" );
@@ -54987,13 +67029,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::mapMemory( vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags, void** ppData, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( offset ), static_cast<VkDeviceSize>( size ), static_cast<VkMemoryMapFlags>( flags ), ppData ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void*>::type Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void*>::type Device::mapMemory( vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags, Dispatch const &d ) const
   {
     void* pData;
     Result result = static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( offset ), static_cast<VkDeviceSize>( size ), static_cast<VkMemoryMapFlags>( flags ), &pData ) );
@@ -55002,13 +67044,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::mergePipelineCaches( vk::PipelineCache dstCache, uint32_t srcCacheCount, const vk::PipelineCache* pSrcCaches, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache*>( pSrcCaches ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergePipelineCaches( vk::PipelineCache dstCache, ArrayProxy<const vk::PipelineCache> srcCaches, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size() , reinterpret_cast<const VkPipelineCache*>( srcCaches.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergePipelineCaches" );
@@ -55016,13 +67058,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( vk::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const vk::ValidationCacheEXT* pSrcCaches, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCacheCount, reinterpret_cast<const VkValidationCacheEXT*>( pSrcCaches ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergeValidationCachesEXT( vk::ValidationCacheEXT dstCache, ArrayProxy<const vk::ValidationCacheEXT> srcCaches, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size() , reinterpret_cast<const VkValidationCacheEXT*>( srcCaches.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergeValidationCachesEXT" );
@@ -55030,43 +67072,43 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::registerEventEXT( const vk::DeviceEventInfoEXT* pDeviceEventInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( pDeviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Fence>::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Fence fence;
+    vk::Fence fence;
     Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
     return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( vk::DisplayKHR display, const vk::DisplayEventInfoEXT* pDisplayEventInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Fence>::type Device::registerDisplayEventEXT( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Fence fence;
+    vk::Fence fence;
     Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
     return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::registerObjectsNVX( vk::ObjectTableNVX objectTable, uint32_t objectCount, const vk::ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectTableEntryNVX* const*>( ppObjectTableEntries ), pObjectIndices ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::registerObjectsNVX( vk::ObjectTableNVX objectTable, ArrayProxy<const vk::ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( pObjectTableEntries.size() == objectIndices.size() );
@@ -55084,13 +67126,13 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::releaseFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::releaseFullScreenExclusiveModeEXT" );
@@ -55100,13 +67142,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::releasePerformanceConfigurationINTEL" );
@@ -55115,13 +67157,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetCommandPool" );
@@ -55130,13 +67172,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::resetDescriptorPool( vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetDescriptorPool( vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetDescriptorPool" );
@@ -55145,13 +67187,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::resetEvent( vk::Event event, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetEvent( Event event, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetEvent( vk::Event event, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetEvent" );
@@ -55159,13 +67201,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const vk::Fence* pFences, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> fences, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetFences( ArrayProxy<const vk::Fence> fences, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkResetFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetFences" );
@@ -55174,20 +67216,20 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
   {
     d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
   {
     d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const vk::DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>( pNameInfo ) ) );
   }
@@ -55201,7 +67243,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const vk::DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>( pTagInfo ) ) );
   }
@@ -55216,13 +67258,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::setEvent( vk::Event event, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::setEvent( Event event, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::setEvent( vk::Event event, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setEvent" );
@@ -55230,13 +67272,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const vk::SwapchainKHR* pSwapchains, const vk::HdrMetadataEXT* pMetadata, Dispatch const &d) const
   {
     d.vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast<const VkSwapchainKHR*>( pSwapchains ), reinterpret_cast<const VkHdrMetadataEXT*>( pMetadata ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const vk::SwapchainKHR> swapchains, ArrayProxy<const vk::HdrMetadataEXT> metadata, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
@@ -55252,13 +67294,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( vk::SwapchainKHR swapChain, vk::Bool32 localDimmingEnable, Dispatch const &d) const
   {
     d.vkSetLocalDimmingAMD( m_device, static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( vk::SwapchainKHR swapChain, vk::Bool32 localDimmingEnable, Dispatch const &d ) const
   {
     d.vkSetLocalDimmingAMD( m_device, static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) );
   }
@@ -55266,13 +67308,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::trimCommandPool( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d) const
   {
     d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::trimCommandPool( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d ) const
   {
     d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
   }
@@ -55280,13 +67322,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d) const
   {
     d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d ) const
   {
     d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
   }
@@ -55308,26 +67350,26 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::unmapMemory( vk::DeviceMemory memory, Dispatch const &d) const
   {
     d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::unmapMemory( vk::DeviceMemory memory, Dispatch const &d ) const
   {
     d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( vk::ObjectTableNVX objectTable, uint32_t objectCount, const vk::ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectEntryTypeNVX*>( pObjectEntryTypes ), pObjectIndices ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::unregisterObjectsNVX( vk::ObjectTableNVX objectTable, ArrayProxy<const vk::ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( objectEntryTypes.size() == objectIndices.size() );
@@ -55344,13 +67386,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
   {
     d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
   {
     d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
   }
@@ -55358,39 +67400,39 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
   {
     d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
   {
     d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const vk::WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const vk::CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const
   {
     d.vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>( pDescriptorCopies ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const vk::WriteDescriptorSet> descriptorWrites, ArrayProxy<const vk::CopyDescriptorSet> descriptorCopies, Dispatch const &d ) const
   {
     d.vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast<const VkCopyDescriptorSet*>( descriptorCopies.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const vk::Fence* pFences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ), static_cast<VkBool32>( waitAll ), timeout ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d ) const
+  VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy<const vk::Fence> fences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkWaitForFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitForFences", { Result::eSuccess, Result::eTimeout } );
@@ -55399,15 +67441,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const vk::AndroidSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createAndroidSurfaceKHR" );
   }
@@ -55415,7 +67457,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55426,15 +67468,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const vk::DebugReportCallbackCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DebugReportCallbackEXT* pCallback, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugReportCallbackEXT*>( pCallback ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DebugReportCallbackEXT callback;
+    vk::DebugReportCallbackEXT callback;
     Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
     return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXT" );
   }
@@ -55442,7 +67484,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DebugReportCallbackEXT callback;
+    vk::DebugReportCallbackEXT callback;
     Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55452,15 +67494,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const vk::DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DebugUtilsMessengerEXT* pMessenger, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( pMessenger ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DebugUtilsMessengerEXT>::type Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DebugUtilsMessengerEXT>::type Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DebugUtilsMessengerEXT messenger;
+    vk::DebugUtilsMessengerEXT messenger;
     Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
     return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXT" );
   }
@@ -55468,7 +67510,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DebugUtilsMessengerEXT messenger;
+    vk::DebugUtilsMessengerEXT messenger;
     Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55478,15 +67520,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const vk::DisplaySurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHR" );
   }
@@ -55494,7 +67536,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55504,15 +67546,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const vk::HeadlessSurfaceCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createHeadlessSurfaceEXT" );
   }
@@ -55520,7 +67562,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55531,15 +67573,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_IOS_MVK
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const vk::IOSSurfaceCreateInfoMVK* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVK" );
   }
@@ -55547,7 +67589,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55559,15 +67601,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_FUCHSIA
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const vk::ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIA" );
   }
@@ -55575,7 +67617,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55587,15 +67629,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_MACOS_MVK
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const vk::MacOSSurfaceCreateInfoMVK* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVK" );
   }
@@ -55603,7 +67645,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55615,15 +67657,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_METAL_EXT
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createMetalSurfaceEXT( const vk::MetalSurfaceCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance, reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance, reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMetalSurfaceEXT" );
   }
@@ -55631,7 +67673,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance, reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55643,15 +67685,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_GGP
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const vk::StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createStreamDescriptorSurfaceGGP" );
   }
@@ -55659,7 +67701,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55671,15 +67713,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_VI_NN
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const vk::ViSurfaceCreateInfoNN* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createViSurfaceNN" );
   }
@@ -55687,7 +67729,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55699,15 +67741,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const vk::WaylandSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWaylandSurfaceKHR" );
   }
@@ -55715,7 +67757,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55727,15 +67769,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const vk::Win32SurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWin32SurfaceKHR" );
   }
@@ -55743,7 +67785,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55755,15 +67797,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const vk::XcbSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXcbSurfaceKHR" );
   }
@@ -55771,7 +67813,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55783,15 +67825,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const vk::XlibSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
     return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHR" );
   }
@@ -55799,7 +67841,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
+    vk::SurfaceKHR surface;
     Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55810,13 +67852,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const
   {
     d.vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, pLayerPrefix, pMessage );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
     VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() );
@@ -55831,59 +67873,59 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( vk::DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::destroy( vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::destroy( vk::DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( vk::DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::destroy( vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::destroy( vk::DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::destroy( const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
@@ -55896,33 +67938,33 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( vk::SurfaceKHR surface, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( vk::SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::destroy( vk::SurfaceKHR surface, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
     d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::destroy( vk::SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
   }
@@ -55974,7 +68016,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
   }
@@ -56026,7 +68068,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, vk::PhysicalDevice* pPhysicalDevices, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( pPhysicalDevices ) ) );
   }
@@ -56091,13 +68133,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const vk::DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d) const
   {
     d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( pCallbackData ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d ) const
   {
     d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( &callbackData ) );
   }
@@ -56105,13 +68147,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, vk::DisplayKHR display, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( vk::DisplayKHR display, Dispatch const &d ) const
   {
     Display dpy;
     Result result = static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
@@ -56121,15 +68163,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const vk::DeviceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Device* pDevice, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDevice*>( pDevice ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Device>::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Device>::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Device device;
+    vk::Device device;
     Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
     return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDevice" );
   }
@@ -56137,7 +68179,7 @@ namespace VULKAN_HPP_NAMESPACE
   template<typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Device,Dispatch>>::type PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Device device;
+    vk::Device device;
     Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
 
     ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
@@ -56147,22 +68189,22 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DisplayModeKHR* pMode, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDisplayModeKHR*>( pMode ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR( vk::DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DisplayModeKHR mode;
+    vk::DisplayModeKHR mode;
     Result result = static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDisplayModeKHR*>( &mode ) ) );
     return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDisplayModeKHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, vk::ExtensionProperties* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
   }
@@ -56214,7 +68256,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, vk::LayerProperties* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
   }
@@ -56266,13 +68308,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModeProperties2KHR* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( pProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( vk::DisplayKHR display, Dispatch const &d ) const
   {
     std::vector<DisplayModeProperties2KHR,Allocator> properties;
     uint32_t propertyCount;
@@ -56294,7 +68336,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( vk::DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<DisplayModeProperties2KHR,Allocator> properties( vectorAllocator );
     uint32_t propertyCount;
@@ -56318,13 +68360,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModePropertiesKHR* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( pProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( vk::DisplayKHR display, Dispatch const &d ) const
   {
     std::vector<DisplayModePropertiesKHR,Allocator> properties;
     uint32_t propertyCount;
@@ -56346,7 +68388,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( vk::DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<DisplayModePropertiesKHR,Allocator> properties( vectorAllocator );
     uint32_t propertyCount;
@@ -56370,37 +68412,37 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const vk::DisplayPlaneInfo2KHR* pDisplayPlaneInfo, vk::DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( pDisplayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( pCapabilities ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilities2KHR>::type PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DisplayPlaneCapabilities2KHR>::type PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d ) const
   {
-    DisplayPlaneCapabilities2KHR capabilities;
+    vk::DisplayPlaneCapabilities2KHR capabilities;
     Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( &displayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( &capabilities ) ) );
     return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( vk::DisplayModeKHR mode, uint32_t planeIndex, vk::DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( pCapabilities ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilitiesKHR>::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DisplayPlaneCapabilitiesKHR>::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( vk::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d ) const
   {
-    DisplayPlaneCapabilitiesKHR capabilities;
+    vk::DisplayPlaneCapabilitiesKHR capabilities;
     Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( &capabilities ) ) );
     return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, vk::DisplayKHR* pDisplays, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>( pDisplays ) ) );
   }
@@ -56452,7 +68494,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, vk::TimeDomainEXT* pTimeDomains, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( pTimeDomains ) ) );
   }
@@ -56504,7 +68546,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, vk::CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV*>( pProperties ) ) );
   }
@@ -56556,7 +68598,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, vk::DisplayPlaneProperties2KHR* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( pProperties ) ) );
   }
@@ -56608,7 +68650,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, vk::DisplayPlanePropertiesKHR* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( pProperties ) ) );
   }
@@ -56660,7 +68702,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t* pPropertyCount, vk::DisplayProperties2KHR* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( pProperties ) ) );
   }
@@ -56712,7 +68754,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, vk::DisplayPropertiesKHR* pProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( pProperties ) ) );
   }
@@ -56764,135 +68806,135 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const vk::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, vk::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::ExternalBufferProperties PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
   {
-    ExternalBufferProperties externalBufferProperties;
+    vk::ExternalBufferProperties externalBufferProperties;
     d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
     return externalBufferProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const vk::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, vk::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
   {
-    ExternalBufferProperties externalBufferProperties;
+    vk::ExternalBufferProperties externalBufferProperties;
     d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
     return externalBufferProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const vk::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, vk::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::ExternalFenceProperties PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
   {
-    ExternalFenceProperties externalFenceProperties;
+    vk::ExternalFenceProperties externalFenceProperties;
     d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
     return externalFenceProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const vk::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, vk::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
   {
-    ExternalFenceProperties externalFenceProperties;
+    vk::ExternalFenceProperties externalFenceProperties;
     d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
     return externalFenceProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, vk::ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( pExternalImageFormatProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d ) const
   {
-    ExternalImageFormatPropertiesNV externalImageFormatProperties;
+    vk::ExternalImageFormatPropertiesNV externalImageFormatProperties;
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( &externalImageFormatProperties ) ) );
     return createResultValue( result, externalImageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getExternalImageFormatPropertiesNV" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const vk::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
   {
-    ExternalSemaphoreProperties externalSemaphoreProperties;
+    vk::ExternalSemaphoreProperties externalSemaphoreProperties;
     d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
     return externalSemaphoreProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const vk::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
   {
-    ExternalSemaphoreProperties externalSemaphoreProperties;
+    vk::ExternalSemaphoreProperties externalSemaphoreProperties;
     d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
     return externalSemaphoreProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( vk::PhysicalDeviceFeatures* pFeatures, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( pFeatures ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceFeatures PhysicalDevice::getFeatures(Dispatch const &d ) const
   {
-    PhysicalDeviceFeatures features;
+    vk::PhysicalDeviceFeatures features;
     d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( &features ) );
     return features;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( vk::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2(Dispatch const &d ) const
   {
-    PhysicalDeviceFeatures2 features;
+    vk::PhysicalDeviceFeatures2 features;
     d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
     return features;
   }
@@ -56900,22 +68942,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2(Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
+    vk::PhysicalDeviceFeatures2& features = structureChain.template get<vk::PhysicalDeviceFeatures2>();
     d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( vk::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
   {
-    PhysicalDeviceFeatures2 features;
+    vk::PhysicalDeviceFeatures2 features;
     d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
     return features;
   }
@@ -56923,113 +68965,113 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
+    vk::PhysicalDeviceFeatures2& features = structureChain.template get<vk::PhysicalDeviceFeatures2>();
     d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( vk::Format format, vk::FormatProperties* pFormatProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( pFormatProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::FormatProperties PhysicalDevice::getFormatProperties( vk::Format format, Dispatch const &d ) const
   {
-    FormatProperties formatProperties;
+    vk::FormatProperties formatProperties;
     d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( &formatProperties ) );
     return formatProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( vk::Format format, vk::FormatProperties2* pFormatProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::FormatProperties2 PhysicalDevice::getFormatProperties2( vk::Format format, Dispatch const &d ) const
   {
-    FormatProperties2 formatProperties;
+    vk::FormatProperties2 formatProperties;
     d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
     return formatProperties;
   }
   template<typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2( vk::Format format, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
+    vk::FormatProperties2& formatProperties = structureChain.template get<vk::FormatProperties2>();
     d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( vk::Format format, vk::FormatProperties2* pFormatProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::FormatProperties2 PhysicalDevice::getFormatProperties2KHR( vk::Format format, Dispatch const &d ) const
   {
-    FormatProperties2 formatProperties;
+    vk::FormatProperties2 formatProperties;
     d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
     return formatProperties;
   }
   template<typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2KHR( vk::Format format, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
+    vk::FormatProperties2& formatProperties = structureChain.template get<vk::FormatProperties2>();
     d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( vk::DeviceGeneratedCommandsFeaturesNVX* pFeatures, vk::DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d ) const
   {
-    DeviceGeneratedCommandsLimitsNVX limits;
+    vk::DeviceGeneratedCommandsLimitsNVX limits;
     d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) );
     return limits;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ImageFormatProperties* pImageFormatProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( pImageFormatProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, Dispatch const &d ) const
   {
-    ImageFormatProperties imageFormatProperties;
+    vk::ImageFormatProperties imageFormatProperties;
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( &imageFormatProperties ) ) );
     return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const vk::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, vk::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
   {
-    ImageFormatProperties2 imageFormatProperties;
+    vk::ImageFormatProperties2 imageFormatProperties;
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
     return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
   }
@@ -57037,22 +69079,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
+    vk::ImageFormatProperties2& imageFormatProperties = structureChain.template get<vk::ImageFormatProperties2>();
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
     return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const vk::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, vk::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
   {
-    ImageFormatProperties2 imageFormatProperties;
+    vk::ImageFormatProperties2 imageFormatProperties;
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
     return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
   }
@@ -57060,37 +69102,37 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
+    vk::ImageFormatProperties2& imageFormatProperties = structureChain.template get<vk::ImageFormatProperties2>();
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
     return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( vk::PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( pMemoryProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties(Dispatch const &d ) const
   {
-    PhysicalDeviceMemoryProperties memoryProperties;
+    vk::PhysicalDeviceMemoryProperties memoryProperties;
     d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( &memoryProperties ) );
     return memoryProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( vk::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
   {
-    PhysicalDeviceMemoryProperties2 memoryProperties;
+    vk::PhysicalDeviceMemoryProperties2 memoryProperties;
     d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
     return memoryProperties;
   }
@@ -57098,22 +69140,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<PhysicalDeviceMemoryProperties2>();
+    vk::PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<vk::PhysicalDeviceMemoryProperties2>();
     d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( vk::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
   {
-    PhysicalDeviceMemoryProperties2 memoryProperties;
+    vk::PhysicalDeviceMemoryProperties2 memoryProperties;
     d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
     return memoryProperties;
   }
@@ -57121,35 +69163,35 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<PhysicalDeviceMemoryProperties2>();
+    vk::PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<vk::PhysicalDeviceMemoryProperties2>();
     d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( vk::SampleCountFlagBits samples, vk::MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( pMultisampleProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( vk::SampleCountFlagBits samples, Dispatch const &d ) const
   {
-    MultisamplePropertiesEXT multisampleProperties;
+    vk::MultisamplePropertiesEXT multisampleProperties;
     d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( &multisampleProperties ) );
     return multisampleProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( vk::SurfaceKHR surface, uint32_t* pRectCount, vk::Rect2D* pRects, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D*>( pRects ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
   {
     std::vector<Rect2D,Allocator> rects;
     uint32_t rectCount;
@@ -57171,7 +69213,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<Rect2D,Allocator> rects( vectorAllocator );
     uint32_t rectCount;
@@ -57195,30 +69237,30 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getProperties( vk::PhysicalDeviceProperties* pProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( pProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceProperties PhysicalDevice::getProperties(Dispatch const &d ) const
   {
-    PhysicalDeviceProperties properties;
+    vk::PhysicalDeviceProperties properties;
     d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
     return properties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( vk::PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceProperties2 PhysicalDevice::getProperties2(Dispatch const &d ) const
   {
-    PhysicalDeviceProperties2 properties;
+    vk::PhysicalDeviceProperties2 properties;
     d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
     return properties;
   }
@@ -57226,22 +69268,22 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2(Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
+    vk::PhysicalDeviceProperties2& properties = structureChain.template get<vk::PhysicalDeviceProperties2>();
     d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( vk::PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
+  VULKAN_HPP_INLINE vk::PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
   {
-    PhysicalDeviceProperties2 properties;
+    vk::PhysicalDeviceProperties2 properties;
     d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
     return properties;
   }
@@ -57249,14 +69291,14 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
+    vk::PhysicalDeviceProperties2& properties = structureChain.template get<vk::PhysicalDeviceProperties2>();
     d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
     return structureChain;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
   }
@@ -57284,7 +69326,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
   }
@@ -57332,7 +69374,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
   }
@@ -57380,13 +69422,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, uint32_t* pPropertyCount, vk::SparseImageFormatProperties* pProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( pProperties ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d ) const
+  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Dispatch const &d ) const
   {
     std::vector<SparseImageFormatProperties,Allocator> properties;
     uint32_t propertyCount;
@@ -57396,7 +69438,7 @@ namespace VULKAN_HPP_NAMESPACE
     return properties;
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<SparseImageFormatProperties,Allocator> properties( vectorAllocator );
     uint32_t propertyCount;
@@ -57408,7 +69450,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const vk::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, vk::SparseImageFormatProperties2* pProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
   }
@@ -57436,7 +69478,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const vk::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, vk::SparseImageFormatProperties2* pProperties, Dispatch const &d) const
   {
     d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
   }
@@ -57464,7 +69506,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, vk::FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, pCombinationCount, reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>( pCombinations ) ) );
   }
@@ -57516,30 +69558,30 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( vk::SurfaceKHR surface, vk::SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( vk::SurfaceKHR surface, Dispatch const &d ) const
   {
-    SurfaceCapabilities2EXT surfaceCapabilities;
+    vk::SurfaceCapabilities2EXT surfaceCapabilities;
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) );
     return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2EXT" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, vk::SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( pSurfaceCapabilities ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
   {
-    SurfaceCapabilities2KHR surfaceCapabilities;
+    vk::SurfaceCapabilities2KHR surfaceCapabilities;
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
     return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
   }
@@ -57547,29 +69589,29 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
-    SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
+    vk::SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<vk::SurfaceCapabilities2KHR>();
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
     return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( vk::SurfaceKHR surface, vk::SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
   {
-    SurfaceCapabilitiesKHR surfaceCapabilities;
+    vk::SurfaceCapabilitiesKHR surfaceCapabilities;
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
     return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilitiesKHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, vk::SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( pSurfaceFormats ) ) );
   }
@@ -57621,13 +69663,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( vk::SurfaceKHR surface, uint32_t* pSurfaceFormatCount, vk::SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
   {
     std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
     uint32_t surfaceFormatCount;
@@ -57649,7 +69691,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<SurfaceFormatKHR,Allocator> surfaceFormats( vectorAllocator );
     uint32_t surfaceFormatCount;
@@ -57674,7 +69716,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, vk::PresentModeKHR* pPresentModes, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
   }
@@ -57727,13 +69769,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( vk::SurfaceKHR surface, uint32_t* pPresentModeCount, vk::PresentModeKHR* pPresentModes, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
   {
     std::vector<PresentModeKHR,Allocator> presentModes;
     uint32_t presentModeCount;
@@ -57755,7 +69797,7 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
   }
   template<typename Allocator, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<PresentModeKHR,Allocator> presentModes( vectorAllocator );
     uint32_t presentModeCount;
@@ -57779,15 +69821,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, vk::SurfaceKHR surface, vk::Bool32* pSupported, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32*>( pSupported ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, vk::SurfaceKHR surface, Dispatch const &d ) const
   {
-    Bool32 supported;
+    vk::Bool32 supported;
     Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32*>( &supported ) ) );
     return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceSupportKHR" );
   }
@@ -57856,15 +69898,15 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, vk::DisplayKHR* pDisplay, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<vk::DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const
   {
-    DisplayKHR display;
+    vk::DisplayKHR display;
     Result result = static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) );
     return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getRandROutputDisplayEXT" );
   }
@@ -57873,13 +69915,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( vk::DisplayKHR display, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( vk::DisplayKHR display, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::releaseDisplayEXT" );
@@ -57887,7 +69929,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t* pCheckpointDataCount, vk::CheckpointDataNV* pCheckpointData, Dispatch const &d) const
   {
     d.vkGetQueueCheckpointDataNV( m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( pCheckpointData ) );
   }
@@ -57915,7 +69957,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
   {
     d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
   }
@@ -57928,13 +69970,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const vk::BindSparseInfo* pBindInfo, vk::Fence fence, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>( pBindInfo ), static_cast<VkFence>( fence ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::bindSparse( ArrayProxy<const vk::BindSparseInfo> bindInfo, vk::Fence fence, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast<const VkBindSparseInfo*>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::bindSparse" );
@@ -57956,7 +69998,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
   {
     d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
   }
@@ -57969,7 +70011,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Queue::presentKHR( const vk::PresentInfoKHR* pPresentInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( pPresentInfo ) ) );
   }
@@ -57984,13 +70026,13 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::setPerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::setPerformanceConfigurationINTEL" );
@@ -57998,13 +70040,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const vk::SubmitInfo* pSubmits, vk::Fence fence, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo*>( pSubmits ), static_cast<VkFence>( fence ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::submit( ArrayProxy<const vk::SubmitInfo> submits, vk::Fence fence, Dispatch const &d ) const
   {
     Result result = static_cast<Result>( d.vkQueueSubmit( m_queue, submits.size() , reinterpret_cast<const VkSubmitInfo*>( submits.data() ), static_cast<VkFence>( fence ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::submit" );
@@ -58125,6 +70167,8 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceBufferDeviceAddressFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceBufferDeviceAddressFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceCoherentMemoryFeaturesAMD>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceCoherentMemoryFeaturesAMD>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceConditionalRenderingFeaturesEXT>{ enum { value = true }; };
@@ -58152,8 +70196,6 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceExternalImageFormatInfo>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFeatures2>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFloat16Int8FeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFloat16Int8FeaturesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceFloatControlsPropertiesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFragmentDensityMapFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFragmentDensityMapFeaturesEXT>{ enum { value = true }; };
@@ -58169,9 +70211,14 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageViewImageFormatInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceImagelessFramebufferFeaturesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceImagelessFramebufferFeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceIndexTypeUint8FeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceIndexTypeUint8FeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceInlineUniformBlockPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceLineRasterizationFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceLineRasterizationFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceLineRasterizationPropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMaintenance3Properties>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceMemoryProperties2, PhysicalDeviceMemoryBudgetPropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMemoryPriorityFeaturesEXT>{ enum { value = true }; };
@@ -58184,6 +70231,8 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewProperties>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePCIBusInfoPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePointClippingProperties>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceProtectedMemoryFeatures>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceProtectedMemoryFeatures>{ enum { value = true }; };
@@ -58200,15 +70249,18 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceScalarBlockLayoutFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderCoreProperties2AMD>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderCorePropertiesAMD>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderDrawParametersFeatures>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderDrawParametersFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderFloat16Int8FeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderFloat16Int8FeaturesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderIntegerFunctions2INTEL>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderIntegerFunctions2INTEL>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderSMBuiltinsFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderSMBuiltinsFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderSMBuiltinsPropertiesNV>{ enum { value = true }; };
@@ -58216,9 +70268,14 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShadingRateImagePropertiesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSubgroupProperties>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceSubgroupSizeControlFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceSubgroupSizeControlFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSubgroupSizeControlPropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTexelBufferAlignmentFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTexelBufferAlignmentFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceMemoryProperties2, PhysicalDeviceTexelBufferAlignmentPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceTexelBufferAlignmentPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceTransformFeedbackPropertiesEXT>{ enum { value = true }; };
@@ -58234,6 +70291,8 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceYcbcrImageArraysFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceYcbcrImageArraysFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineColorBlendStateCreateInfo, PipelineColorBlendAdvancedStateCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineCompilerControlCreateInfoAMD>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ComputePipelineCreateInfo, PipelineCompilerControlCreateInfoAMD>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageModulationStateCreateInfoNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageReductionStateCreateInfoNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageToColorStateCreateInfoNV>{ enum { value = true }; };
@@ -58243,10 +70302,12 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineDiscardRectangleStateCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationDepthClipStateCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationLineStateCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateRasterizationOrderAMD>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateStreamCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineRepresentativeFragmentTestStateCreateInfoNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineSampleLocationsStateCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineShaderStageCreateInfo, PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineTessellationStateCreateInfo, PipelineTessellationDomainOriginStateCreateInfo>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineVertexInputStateCreateInfo, PipelineVertexInputDivisorStateCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportCoarseSampleOrderStateCreateInfoNV>{ enum { value = true }; };
@@ -58382,6 +70443,7 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
     PFN_vkCmdSetEvent vkCmdSetEvent = 0;
     PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
+    PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;
     PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
     PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0;
     PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0;
@@ -58542,6 +70604,9 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
     PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0;
     PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0;
+    PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
+    PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0;
+    PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0;
     PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
     PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
     PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
@@ -58836,6 +70901,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
       vkCmdSetEvent = PFN_vkCmdSetEvent( device ? vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) : vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
       vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
+      vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
       vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( device ? vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) : vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
       vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) );
       vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
@@ -58995,6 +71061,9 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) );
       vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( device ? vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) : vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) );
       vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( device ? vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) );
+      vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( device ? vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
+      vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) );
+      vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( device ? vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) );
       vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( device ? vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) : vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
       vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( device ? vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) : vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
       vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );
diff --git a/include/vulkan/vulkan_android.h b/include/vulkan/vulkan_android.h
index 1861802..9b8d3e2 100644
--- a/include/vulkan/vulkan_android.h
+++ b/include/vulkan/vulkan_android.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_ANDROID_H_
 #define VULKAN_ANDROID_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_KHR_android_surface 1
 struct ANativeWindow;
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 544f24f..50f72f6 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_CORE_H_
 #define VULKAN_CORE_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_VERSION_1_0 1
 #include "vk_platform.h"
@@ -43,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 114
+#define VK_HEADER_VERSION 121
 
 
 #define VK_NULL_HANDLE 0
@@ -307,6 +308,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
     VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
     VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
@@ -327,7 +329,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
     VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = 1000082000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = 1000082000,
     VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
     VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
@@ -446,6 +448,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
+    VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
     VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
@@ -467,7 +470,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL = 1000209000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,
     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = 1000210000,
     VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,
     VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002,
@@ -484,6 +487,11 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
     VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000,
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
@@ -507,7 +515,17 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
     VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
+    VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
+    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
+    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
+    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
+    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
@@ -546,6 +564,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
@@ -830,6 +849,20 @@ typedef enum VkFormat {
     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
+    VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
+    VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
+    VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
+    VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
+    VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
+    VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
+    VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
+    VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
+    VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
+    VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
+    VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
+    VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
+    VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
+    VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
     VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
     VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
@@ -1176,6 +1209,7 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
     VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
+    VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
     VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
     VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
     VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
@@ -1208,6 +1242,7 @@ typedef enum VkSamplerAddressMode {
     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
+    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
     VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
     VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
     VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
@@ -1289,6 +1324,7 @@ typedef enum VkIndexType {
     VK_INDEX_TYPE_UINT16 = 0,
     VK_INDEX_TYPE_UINT32 = 1,
     VK_INDEX_TYPE_NONE_NV = 1000165000,
+    VK_INDEX_TYPE_UINT8_EXT = 1000265000,
     VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
     VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
     VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
@@ -1473,6 +1509,8 @@ typedef enum VkMemoryPropertyFlagBits {
     VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
     VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
+    VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040,
+    VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080,
     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkMemoryPropertyFlagBits;
 typedef VkFlags VkMemoryPropertyFlags;
@@ -1626,6 +1664,10 @@ typedef enum VkImageViewCreateFlagBits {
     VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkImageViewCreateFlagBits;
 typedef VkFlags VkImageViewCreateFlags;
+
+typedef enum VkShaderModuleCreateFlagBits {
+    VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkShaderModuleCreateFlagBits;
 typedef VkFlags VkShaderModuleCreateFlags;
 typedef VkFlags VkPipelineCacheCreateFlags;
 
@@ -1636,11 +1678,19 @@ typedef enum VkPipelineCreateFlagBits {
     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
     VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
     VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
+    VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
+    VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
     VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkPipelineCreateFlagBits;
 typedef VkFlags VkPipelineCreateFlags;
+
+typedef enum VkPipelineShaderStageCreateFlagBits {
+    VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001,
+    VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002,
+    VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineShaderStageCreateFlagBits;
 typedef VkFlags VkPipelineShaderStageCreateFlags;
 
 typedef enum VkShaderStageFlagBits {
@@ -1719,6 +1769,10 @@ typedef enum VkFramebufferCreateFlagBits {
     VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkFramebufferCreateFlagBits;
 typedef VkFlags VkFramebufferCreateFlags;
+
+typedef enum VkRenderPassCreateFlagBits {
+    VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkRenderPassCreateFlagBits;
 typedef VkFlags VkRenderPassCreateFlags;
 
 typedef enum VkAttachmentDescriptionFlagBits {
@@ -1814,7 +1868,8 @@ typedef VkFlags VkCommandBufferResetFlags;
 typedef enum VkStencilFaceFlagBits {
     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
-    VK_STENCIL_FRONT_AND_BACK = 0x00000003,
+    VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
+    VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkStencilFaceFlagBits;
 typedef VkFlags VkStencilFaceFlags;
@@ -5030,7 +5085,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(
 #define VK_KHR_display 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
-#define VK_KHR_DISPLAY_SPEC_VERSION       21
+#define VK_KHR_DISPLAY_SPEC_VERSION       23
 #define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
 
 typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
@@ -5153,7 +5208,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
 
 
 #define VK_KHR_display_swapchain 1
-#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
+#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10
 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
 typedef struct VkDisplayPresentInfoKHR {
     VkStructureType    sType;
@@ -5176,7 +5231,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
 
 
 #define VK_KHR_sampler_mirror_clamp_to_edge 1
-#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
+#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3
 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
 
 
@@ -5192,7 +5247,7 @@ typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesK
 
 
 #define VK_KHR_get_physical_device_properties2 1
-#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
+#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2
 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
 typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
 
@@ -5257,7 +5312,7 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
 
 
 #define VK_KHR_device_group 1
-#define VK_KHR_DEVICE_GROUP_SPEC_VERSION  3
+#define VK_KHR_DEVICE_GROUP_SPEC_VERSION  4
 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
 typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
 
@@ -5535,12 +5590,14 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
 #define VK_KHR_shader_float16_int8 1
 #define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
 #define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
-typedef struct VkPhysicalDeviceFloat16Int8FeaturesKHR {
+typedef struct VkPhysicalDeviceShaderFloat16Int8FeaturesKHR {
     VkStructureType    sType;
     void*              pNext;
     VkBool32           shaderFloat16;
     VkBool32           shaderInt8;
-} VkPhysicalDeviceFloat16Int8FeaturesKHR;
+} VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
+
+typedef VkPhysicalDeviceShaderFloat16Int8FeaturesKHR VkPhysicalDeviceFloat16Int8FeaturesKHR;
 
 
 
@@ -6040,7 +6097,7 @@ typedef struct VkImageFormatListCreateInfoKHR {
 #define VK_KHR_sampler_ycbcr_conversion 1
 typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
 
-#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1
+#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14
 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
 typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
 
@@ -6212,28 +6269,38 @@ typedef struct VkPhysicalDeviceDriverPropertiesKHR {
 
 
 #define VK_KHR_shader_float_controls 1
-#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 1
+#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4
 #define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"
+
+typedef enum VkShaderFloatControlsIndependenceKHR {
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = 0,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = 1,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = 2,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_BEGIN_RANGE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_END_RANGE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_RANGE_SIZE_KHR = (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR + 1),
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkShaderFloatControlsIndependenceKHR;
 typedef struct VkPhysicalDeviceFloatControlsPropertiesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           separateDenormSettings;
-    VkBool32           separateRoundingModeSettings;
-    VkBool32           shaderSignedZeroInfNanPreserveFloat16;
-    VkBool32           shaderSignedZeroInfNanPreserveFloat32;
-    VkBool32           shaderSignedZeroInfNanPreserveFloat64;
-    VkBool32           shaderDenormPreserveFloat16;
-    VkBool32           shaderDenormPreserveFloat32;
-    VkBool32           shaderDenormPreserveFloat64;
-    VkBool32           shaderDenormFlushToZeroFloat16;
-    VkBool32           shaderDenormFlushToZeroFloat32;
-    VkBool32           shaderDenormFlushToZeroFloat64;
-    VkBool32           shaderRoundingModeRTEFloat16;
-    VkBool32           shaderRoundingModeRTEFloat32;
-    VkBool32           shaderRoundingModeRTEFloat64;
-    VkBool32           shaderRoundingModeRTZFloat16;
-    VkBool32           shaderRoundingModeRTZFloat32;
-    VkBool32           shaderRoundingModeRTZFloat64;
+    VkStructureType                         sType;
+    void*                                   pNext;
+    VkShaderFloatControlsIndependenceKHR    denormBehaviorIndependence;
+    VkShaderFloatControlsIndependenceKHR    roundingModeIndependence;
+    VkBool32                                shaderSignedZeroInfNanPreserveFloat16;
+    VkBool32                                shaderSignedZeroInfNanPreserveFloat32;
+    VkBool32                                shaderSignedZeroInfNanPreserveFloat64;
+    VkBool32                                shaderDenormPreserveFloat16;
+    VkBool32                                shaderDenormPreserveFloat32;
+    VkBool32                                shaderDenormPreserveFloat64;
+    VkBool32                                shaderDenormFlushToZeroFloat16;
+    VkBool32                                shaderDenormFlushToZeroFloat32;
+    VkBool32                                shaderDenormFlushToZeroFloat64;
+    VkBool32                                shaderRoundingModeRTEFloat16;
+    VkBool32                                shaderRoundingModeRTEFloat32;
+    VkBool32                                shaderRoundingModeRTEFloat64;
+    VkBool32                                shaderRoundingModeRTZFloat16;
+    VkBool32                                shaderRoundingModeRTZFloat32;
+    VkBool32                                shaderRoundingModeRTZFloat64;
 } VkPhysicalDeviceFloatControlsPropertiesKHR;
 
 
@@ -6310,6 +6377,99 @@ typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR {
 
 
 
+#define VK_KHR_pipeline_executable_properties 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
+
+typedef enum VkPipelineExecutableStatisticFormatKHR {
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BEGIN_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_END_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR,
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_RANGE_SIZE_KHR = (VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR + 1),
+    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPipelineExecutableStatisticFormatKHR;
+typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           pipelineExecutableInfo;
+} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+
+typedef struct VkPipelineInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkPipeline         pipeline;
+} VkPipelineInfoKHR;
+
+typedef struct VkPipelineExecutablePropertiesKHR {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkShaderStageFlags    stages;
+    char                  name[VK_MAX_DESCRIPTION_SIZE];
+    char                  description[VK_MAX_DESCRIPTION_SIZE];
+    uint32_t              subgroupSize;
+} VkPipelineExecutablePropertiesKHR;
+
+typedef struct VkPipelineExecutableInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkPipeline         pipeline;
+    uint32_t           executableIndex;
+} VkPipelineExecutableInfoKHR;
+
+typedef union VkPipelineExecutableStatisticValueKHR {
+    VkBool32    b32;
+    int64_t     i64;
+    uint64_t    u64;
+    double      f64;
+} VkPipelineExecutableStatisticValueKHR;
+
+typedef struct VkPipelineExecutableStatisticKHR {
+    VkStructureType                           sType;
+    void*                                     pNext;
+    char                                      name[VK_MAX_DESCRIPTION_SIZE];
+    char                                      description[VK_MAX_DESCRIPTION_SIZE];
+    VkPipelineExecutableStatisticFormatKHR    format;
+    VkPipelineExecutableStatisticValueKHR     value;
+} VkPipelineExecutableStatisticKHR;
+
+typedef struct VkPipelineExecutableInternalRepresentationKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    char               name[VK_MAX_DESCRIPTION_SIZE];
+    char               description[VK_MAX_DESCRIPTION_SIZE];
+    VkBool32           isText;
+    size_t             dataSize;
+    void*              pData;
+} VkPipelineExecutableInternalRepresentationKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+#endif
+
+
 #define VK_EXT_debug_report 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION  9
@@ -6656,7 +6816,7 @@ VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(
 
 
 #define VK_AMD_draw_indirect_count 1
-#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
+#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2
 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
@@ -6863,6 +7023,17 @@ typedef struct VkValidationFlagsEXT {
 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
 
 
+#define VK_EXT_texture_compression_astc_hdr 1
+#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1
+#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
+typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           textureCompressionASTC_HDR;
+} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+
+
+
 #define VK_EXT_astc_decode_mode 1
 #define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
 #define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
@@ -6881,7 +7052,7 @@ typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
 
 
 #define VK_EXT_conditional_rendering 1
-#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1
+#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2
 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
 
 typedef enum VkConditionalRenderingFlagBitsEXT {
@@ -7513,7 +7684,7 @@ typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
 
 
 #define VK_EXT_hdr_metadata 1
-#define VK_EXT_HDR_METADATA_SPEC_VERSION  1
+#define VK_EXT_HDR_METADATA_SPEC_VERSION  2
 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
 typedef struct VkXYColorEXT {
     float    x;
@@ -7697,7 +7868,7 @@ VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(
 
 
 #define VK_EXT_sampler_filter_minmax 1
-#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
+#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2
 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
 
 typedef enum VkSamplerReductionModeEXT {
@@ -8280,6 +8451,15 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)
 #define VK_NV_RAY_TRACING_EXTENSION_NAME  "VK_NV_ray_tracing"
 #define VK_SHADER_UNUSED_NV               (~0U)
 
+typedef enum VkAccelerationStructureTypeNV {
+    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0,
+    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1,
+    VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
+    VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
+    VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV + 1),
+    VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkAccelerationStructureTypeNV;
+
 typedef enum VkRayTracingShaderGroupTypeNV {
     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0,
     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1,
@@ -8299,15 +8479,6 @@ typedef enum VkGeometryTypeNV {
     VK_GEOMETRY_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
 } VkGeometryTypeNV;
 
-typedef enum VkAccelerationStructureTypeNV {
-    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0,
-    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1,
-    VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
-    VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
-    VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV + 1),
-    VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
-} VkAccelerationStructureTypeNV;
-
 typedef enum VkCopyAccelerationStructureModeNV {
     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0,
     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1,
@@ -8575,7 +8746,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(
 
 
 #define VK_NV_representative_fragment_test 1
-#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1
+#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2
 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
     VkStructureType    sType;
@@ -8679,6 +8850,22 @@ VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(
 #endif
 
 
+#define VK_AMD_pipeline_compiler_control 1
+#define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1
+#define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control"
+
+typedef enum VkPipelineCompilerControlFlagBitsAMD {
+    VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkPipelineCompilerControlFlagBitsAMD;
+typedef VkFlags VkPipelineCompilerControlFlagsAMD;
+typedef struct VkPipelineCompilerControlCreateInfoAMD {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkPipelineCompilerControlFlagsAMD    compilerControlFlags;
+} VkPipelineCompilerControlCreateInfoAMD;
+
+
+
 #define VK_EXT_calibrated_timestamps 1
 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
@@ -8718,7 +8905,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(
 
 
 #define VK_AMD_shader_core_properties 1
-#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2
 #define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
     VkStructureType    sType;
@@ -8908,7 +9095,7 @@ typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
 
 
 #define VK_NV_shader_image_footprint 1
-#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1
+#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2
 #define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
     VkStructureType    sType;
@@ -8977,13 +9164,13 @@ VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(
 
 
 #define VK_INTEL_shader_integer_functions2 1
-#define VK_INTEL_SHADER_INTEGER_FUNCTIONS2_SPEC_VERSION 1
-#define VK_INTEL_SHADER_INTEGER_FUNCTIONS2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
-typedef struct VkPhysicalDeviceShaderIntegerFunctions2INTEL {
+#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1
+#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
+typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
     VkStructureType    sType;
     void*              pNext;
     VkBool32           shaderIntegerFunctions2;
-} VkPhysicalDeviceShaderIntegerFunctions2INTEL;
+} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
 
 
 
@@ -9225,6 +9412,61 @@ typedef struct VkPhysicalDeviceScalarBlockLayoutFeaturesEXT {
 #define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
 
 
+#define VK_EXT_subgroup_size_control 1
+#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2
+#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
+typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           subgroupSizeControl;
+    VkBool32           computeFullSubgroups;
+} VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
+
+typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
+    VkStructureType       sType;
+    void*                 pNext;
+    uint32_t              minSubgroupSize;
+    uint32_t              maxSubgroupSize;
+    uint32_t              maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags    requiredSubgroupSizeStages;
+} VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
+
+typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           requiredSubgroupSize;
+} VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+
+
+
+#define VK_AMD_shader_core_properties2 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2"
+
+typedef enum VkShaderCorePropertiesFlagBitsAMD {
+    VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkShaderCorePropertiesFlagBitsAMD;
+typedef VkFlags VkShaderCorePropertiesFlagsAMD;
+typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {
+    VkStructureType                   sType;
+    void*                             pNext;
+    VkShaderCorePropertiesFlagsAMD    shaderCoreFeatures;
+    uint32_t                          activeComputeUnitCount;
+} VkPhysicalDeviceShaderCoreProperties2AMD;
+
+
+
+#define VK_AMD_device_coherent_memory 1
+#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1
+#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory"
+typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           deviceCoherentMemory;
+} VkPhysicalDeviceCoherentMemoryFeaturesAMD;
+
+
+
 #define VK_EXT_memory_budget 1
 #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
 #define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
@@ -9312,15 +9554,16 @@ typedef struct VkImageStencilUsageCreateInfoEXT {
 
 
 #define VK_EXT_validation_features 1
-#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 1
+#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 2
 #define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
 
 typedef enum VkValidationFeatureEnableEXT {
     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
+    VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,
     VK_VALIDATION_FEATURE_ENABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
-    VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
-    VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1),
+    VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT,
+    VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1),
     VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
 } VkValidationFeatureEnableEXT;
 
@@ -9506,6 +9749,56 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
 #endif
 
 
+#define VK_EXT_line_rasterization 1
+#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
+#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
+
+typedef enum VkLineRasterizationModeEXT {
+    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
+    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
+    VK_LINE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
+    VK_LINE_RASTERIZATION_MODE_END_RANGE_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT,
+    VK_LINE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT + 1),
+    VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkLineRasterizationModeEXT;
+typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rectangularLines;
+    VkBool32           bresenhamLines;
+    VkBool32           smoothLines;
+    VkBool32           stippledRectangularLines;
+    VkBool32           stippledBresenhamLines;
+    VkBool32           stippledSmoothLines;
+} VkPhysicalDeviceLineRasterizationFeaturesEXT;
+
+typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           lineSubPixelPrecisionBits;
+} VkPhysicalDeviceLineRasterizationPropertiesEXT;
+
+typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkLineRasterizationModeEXT    lineRasterizationMode;
+    VkBool32                      stippledLineEnable;
+    uint32_t                      lineStippleFactor;
+    uint16_t                      lineStipplePattern;
+} VkPipelineRasterizationLineStateCreateInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
+#endif
+
+
 #define VK_EXT_host_query_reset 1
 #define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1
 #define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"
@@ -9526,6 +9819,17 @@ VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
 #endif
 
 
+#define VK_EXT_index_type_uint8 1
+#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
+#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
+typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           indexTypeUint8;
+} VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
+
+
+
 #define VK_EXT_shader_demote_to_helper_invocation 1
 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1
 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
diff --git a/include/vulkan/vulkan_fuchsia.h b/include/vulkan/vulkan_fuchsia.h
index 4c62a7c..81ebe55 100644
--- a/include/vulkan/vulkan_fuchsia.h
+++ b/include/vulkan/vulkan_fuchsia.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_FUCHSIA_H_
 #define VULKAN_FUCHSIA_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_FUCHSIA_imagepipe_surface 1
 #define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
diff --git a/include/vulkan/vulkan_ggp.h b/include/vulkan/vulkan_ggp.h
index 3d67c4b..fd30613 100644
--- a/include/vulkan/vulkan_ggp.h
+++ b/include/vulkan/vulkan_ggp.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_GGP_H_
 #define VULKAN_GGP_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_GGP_stream_descriptor_surface 1
 #define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1
diff --git a/include/vulkan/vulkan_ios.h b/include/vulkan/vulkan_ios.h
index 1846df5..72ef1a8 100644
--- a/include/vulkan/vulkan_ios.h
+++ b/include/vulkan/vulkan_ios.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_IOS_H_
 #define VULKAN_IOS_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_MVK_ios_surface 1
 #define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
diff --git a/include/vulkan/vulkan_macos.h b/include/vulkan/vulkan_macos.h
index dca623b..e6e5dea 100644
--- a/include/vulkan/vulkan_macos.h
+++ b/include/vulkan/vulkan_macos.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_MACOS_H_
 #define VULKAN_MACOS_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_MVK_macos_surface 1
 #define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
diff --git a/include/vulkan/vulkan_metal.h b/include/vulkan/vulkan_metal.h
index 1650523..3dec68c 100644
--- a/include/vulkan/vulkan_metal.h
+++ b/include/vulkan/vulkan_metal.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_METAL_H_
 #define VULKAN_METAL_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_EXT_metal_surface 1
 
diff --git a/include/vulkan/vulkan_vi.h b/include/vulkan/vulkan_vi.h
index 50aa27d..6fb66f9 100644
--- a/include/vulkan/vulkan_vi.h
+++ b/include/vulkan/vulkan_vi.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_VI_H_
 #define VULKAN_VI_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_NN_vi_surface 1
 #define VK_NN_VI_SURFACE_SPEC_VERSION     1
diff --git a/include/vulkan/vulkan_wayland.h b/include/vulkan/vulkan_wayland.h
index 12a5f04..599d05b 100644
--- a/include/vulkan/vulkan_wayland.h
+++ b/include/vulkan/vulkan_wayland.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_WAYLAND_H_
 #define VULKAN_WAYLAND_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_KHR_wayland_surface 1
 #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
diff --git a/include/vulkan/vulkan_win32.h b/include/vulkan/vulkan_win32.h
index a61a7d8..20a1dc0 100644
--- a/include/vulkan/vulkan_win32.h
+++ b/include/vulkan/vulkan_win32.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_WIN32_H_
 #define VULKAN_WIN32_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_KHR_win32_surface 1
 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
@@ -246,7 +247,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
 
 
 #define VK_NV_win32_keyed_mutex 1
-#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
 #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
 typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
     VkStructureType          sType;
@@ -263,7 +264,7 @@ typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
 
 
 #define VK_EXT_full_screen_exclusive 1
-#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 3
+#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
 #define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
 
 typedef enum VkFullScreenExclusiveEXT {
diff --git a/include/vulkan/vulkan_xcb.h b/include/vulkan/vulkan_xcb.h
index 7d6905d..4cc0bc0 100644
--- a/include/vulkan/vulkan_xcb.h
+++ b/include/vulkan/vulkan_xcb.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_XCB_H_
 #define VULKAN_XCB_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_KHR_xcb_surface 1
 #define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
diff --git a/include/vulkan/vulkan_xlib.h b/include/vulkan/vulkan_xlib.h
index 7a05d29..ee2b48a 100644
--- a/include/vulkan/vulkan_xlib.h
+++ b/include/vulkan/vulkan_xlib.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_XLIB_H_
 #define VULKAN_XLIB_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_KHR_xlib_surface 1
 #define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
diff --git a/include/vulkan/vulkan_xlib_xrandr.h b/include/vulkan/vulkan_xlib_xrandr.h
index 3a20953..08c4fd7 100644
--- a/include/vulkan/vulkan_xlib_xrandr.h
+++ b/include/vulkan/vulkan_xlib_xrandr.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_XLIB_XRANDR_H_
 #define VULKAN_XLIB_XRANDR_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
@@ -27,6 +23,11 @@ extern "C" {
 */
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 #define VK_EXT_acquire_xlib_display 1
 #define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
diff --git a/registry/cgenerator.py b/registry/cgenerator.py
index 7f2d9bc..75e03cf 100644
--- a/registry/cgenerator.py
+++ b/registry/cgenerator.py
@@ -134,15 +134,11 @@ class COutputGenerator(OutputGenerator):
                      'group', 'bitmask', 'funcpointer', 'struct']
     ALL_SECTIONS = TYPE_SECTIONS + ['commandPointer', 'command']
 
-    def __init__(self,
-                 errFile = sys.stderr,
-                 warnFile = sys.stderr,
-                 diagFile = sys.stdout):
-        OutputGenerator.__init__(self, errFile, warnFile, diagFile)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         # Internal state - accumulators for different inner block text
         self.sections = {section: [] for section in self.ALL_SECTIONS}
         self.feature_not_empty = False
-        self.need_platform_include = False
         self.may_alias = None
 
     def beginFile(self, genOpts):
@@ -156,16 +152,19 @@ class COutputGenerator(OutputGenerator):
             write('#ifndef', headerSym, file=self.outFile)
             write('#define', headerSym, '1', file=self.outFile)
             self.newline()
-        write('#ifdef __cplusplus', file=self.outFile)
-        write('extern "C" {', file=self.outFile)
-        write('#endif', file=self.outFile)
-        self.newline()
 
         # User-supplied prefix text, if any (list of strings)
         if genOpts.prefixText:
             for s in genOpts.prefixText:
                 write(s, file=self.outFile)
 
+        # C++ extern wrapper - after prefix lines so they can add includes.
+        self.newline()
+        write('#ifdef __cplusplus', file=self.outFile)
+        write('extern "C" {', file=self.outFile)
+        write('#endif', file=self.outFile)
+        self.newline()
+
     def endFile(self):
         # C-specific
         # Finish C++ wrapper and multiple inclusion protection
@@ -206,14 +205,6 @@ class COutputGenerator(OutputGenerator):
                     self.newline()
                     write('#define', self.featureName, '1', file=self.outFile)
                     for section in self.TYPE_SECTIONS:
-                        # OpenXR:
-                        # If we need the explicit include of the external platform header,
-                        # put it right before the function pointer definitions
-                        if section == "funcpointer" and self.need_platform_include:
-                            write('// Include for OpenXR Platform-Specific Types', file=self.outFile)
-                            write('#include "openxr_platform.h"', file=self.outFile)
-                            self.newline()
-                            self.need_platform_include = False
                         contents = self.sections[section]
                         if contents:
                             write('\n'.join(contents), file=self.outFile)
@@ -292,27 +283,19 @@ class COutputGenerator(OutputGenerator):
     def genProtectString(self, protect_str):
         protect_if_str = ''
         protect_end_str = ''
-        protect_list = []
-        if protect_str:
-            if ',' in protect_str:
-                protect_list.extend(protect_str.split(","))
-                protect_def_str = ''
-                count = 0
-                for protect_define in protect_list:
-                    if count > 0:
-                        protect_def_str += ' &&'
-                    protect_def_str += ' defined(%s)' % protect_define
-                    count = count + 1
-                    count = count + 1
-                protect_if_str  = '#if'
-                protect_if_str += protect_def_str
-                protect_if_str += '\n'
-                protect_end_str  = '#endif //'
-                protect_end_str += protect_def_str
-                protect_end_str += '\n'
-            else:
-                protect_if_str += '#ifdef %s\n' % protect_str
-                protect_end_str += '#endif // %s\n' % protect_str
+        if not protect_str:
+            return (protect_if_str, protect_end_str)
+
+        if ',' in protect_str:
+            protect_list = protect_str.split(",")
+            protect_defs = ('defined(%s)' % d for d in protect_list)
+            protect_def_str = ' && '.join(protect_defs)
+            protect_if_str = '#if %s\n' % protect_def_str
+            protect_end_str = '#endif // %s\n' % protect_def_str
+        else:
+            protect_if_str = '#ifdef %s\n' % protect_str
+            protect_end_str = '#endif // %s\n' % protect_str
+
         return (protect_if_str, protect_end_str)
 
     def typeMayAlias(self, typeName):
@@ -326,11 +309,10 @@ class COutputGenerator(OutputGenerator):
                                  if data.elem.get('mayalias') == 'true')
 
             # Every type mentioned in some other type's parentstruct attribute.
-            self.may_alias.update(set(x for x in
-                                      [otherType.elem.get('parentstruct')
-                                       for _, otherType in self.registry.typedict.items()]
-                                      if x is not None
-                                      ))
+            parent_structs = (otherType.elem.get('parentstruct')
+                              for otherType in self.registry.typedict.values())
+            self.may_alias.update(set(x for x in parent_structs
+                                      if x is not None))
         return typeName in self.may_alias
 
     # Struct (e.g. C "struct" type) generation.
@@ -364,9 +346,7 @@ class COutputGenerator(OutputGenerator):
 
             body += ' ' + typeName + ' {\n'
 
-            targetLen = 0
-            for member in typeElem.findall('.//member'):
-                targetLen = max(targetLen, self.getCParamTypeLength(member))
+            targetLen = self.getMaxCParamTypeLength(typeinfo)
             for member in typeElem.findall('.//member'):
                 body += self.makeCParamDecl(member, targetLen + 4)
                 body += ';\n'
diff --git a/registry/conventions.py b/registry/conventions.py
index b37a494..8991b17 100644
--- a/registry/conventions.py
+++ b/registry/conventions.py
@@ -17,35 +17,96 @@
 # Base class for working-group-specific style conventions,
 # used in generation.
 
-from abc import ABCMeta, abstractmethod
+from enum import Enum
 
-ABC = ABCMeta('ABC', (object,), {})
+# Type categories that respond "False" to isStructAlwaysValid
+# basetype is home to typedefs like ..Bool32
+CATEGORIES_REQUIRING_VALIDATION = set(('handle',
+                                       'enum',
+                                       'bitmask',
+                                       'basetype',
+                                       None))
 
-class ConventionsBase(ABC):
+# These are basic C types pulled in via openxr_platform_defines.h
+TYPES_KNOWN_ALWAYS_VALID = set(('char',
+                                'float',
+                                'int8_t', 'uint8_t',
+                                'int32_t', 'uint32_t',
+                                'int64_t', 'uint64_t',
+                                'size_t',
+                                'uintptr_t',
+                                'int',
+                                ))
+
+
+class ProseListFormats(Enum):
+    """A connective, possibly with a quantifier."""
+    AND = 0
+    EACH_AND = 1
+    OR = 2
+    ANY_OR = 3
+
+    @classmethod
+    def from_string(cls, s):
+        if s == 'or':
+            return cls.OR
+        if s == 'and':
+            return cls.AND
+        return None
+
+    @property
+    def connective(self):
+        if self in (ProseListFormats.OR, ProseListFormats.ANY_OR):
+            return 'or'
+        return 'and'
+
+    def quantifier(self, n):
+        """Return the desired quantifier for a list of a given length."""
+        if self == ProseListFormats.ANY_OR:
+            if n > 1:
+                return 'any of '
+        elif self == ProseListFormats.EACH_AND:
+            if n > 2:
+                return 'each of '
+            if n == 2:
+                return 'both of '
+        return ''
+
+
+class ConventionsBase:
     """WG-specific conventions."""
 
-    @abstractmethod
+    def __init__(self):
+        self._command_prefix = None
+        self._type_prefix = None
+
     def formatExtension(self, name):
-        """Mark up a name as an extension for the spec."""
+        """Mark up a name as an extension for the spec.
+
+        Must implement."""
         raise NotImplementedError
 
     @property
-    @abstractmethod
     def null(self):
         """Preferred spelling of NULL."""
         raise NotImplementedError
 
-    def makeProseList(self, elements, connective='and'):
+    def makeProseList(self, elements, fmt=ProseListFormats.AND, with_verb=False, *args, **kwargs):
         """Make a (comma-separated) list for use in prose.
 
         Adds a connective (by default, 'and')
         before the last element if there are more than 1.
 
+        Adds the right one of "is" or "are" to the end if with_verb is true.
+
+        Optionally adds a quantifier (like 'any') before a list of 2 or more,
+        if specified by fmt.
+
         Override with a different method or different call to
         _implMakeProseList if you want to add a comma for two elements,
         or not use a serial comma.
         """
-        return self._implMakeProseList(elements, connective)
+        return self._implMakeProseList(elements, fmt, with_verb, *args, **kwargs)
 
     @property
     def struct_macro(self):
@@ -55,20 +116,20 @@ class ConventionsBase(ABC):
         """
         return 'sname:'
 
-    def makeStructName(self, name):
-        """Prepend the appropriate format macro for a structure to a structure type name.
-
-        Uses struct_macro, so just override that if you want to change behavior.
-        """
-        return self.struct_macro + name
-
     @property
     def external_macro(self):
         """Get the appropriate format macro for an external type like uint32_t.
 
         May override.
         """
-        return 'basetype:'
+        return 'code:'
+
+    def makeStructName(self, name):
+        """Prepend the appropriate format macro for a structure to a structure type name.
+
+        Uses struct_macro, so just override that if you want to change behavior.
+        """
+        return self.struct_macro + name
 
     def makeExternalTypeName(self, name):
         """Prepend the appropriate format macro for an external type like uint32_t to a type name.
@@ -77,7 +138,7 @@ class ConventionsBase(ABC):
         """
         return self.external_macro + name
 
-    def _implMakeProseList(self, elements, connective, comma_for_two_elts=False, serial_comma=True):
+    def _implMakeProseList(self, elements, fmt, with_verb, comma_for_two_elts=False, serial_comma=True):
         """Internal-use implementation to make a (comma-separated) list for use in prose.
 
         Adds a connective (by default, 'and')
@@ -85,48 +146,171 @@ class ConventionsBase(ABC):
         and only includes commas if there are more than 2
         (if comma_for_two_elts is False).
 
+        Adds the right one of "is" or "are" to the end if with_verb is true.
+
+        Optionally adds a quantifier (like 'any') before a list of 2 or more,
+        if specified by fmt.
+
         Don't edit these defaults, override self.makeProseList().
         """
         assert(serial_comma)  # didn't implement what we didn't need
+        if isinstance(fmt, str):
+            fmt = ProseListFormats.from_string(fmt)
+
         my_elts = list(elements)
         if len(my_elts) > 1:
-            my_elts[-1] = '{} {}'.format(connective, my_elts[-1])
+            my_elts[-1] = '{} {}'.format(fmt.connective, my_elts[-1])
 
         if not comma_for_two_elts and len(my_elts) <= 2:
-            return ' '.join(my_elts)
-        return ', '.join(my_elts)
+            prose = ' '.join(my_elts)
+        else:
+            prose = ', '.join(my_elts)
+
+        quantifier = fmt.quantifier(len(my_elts))
+
+        parts = [quantifier, prose]
+
+        if with_verb:
+            if len(my_elts) > 1:
+                parts.append(' are')
+            else:
+                parts.append(' is')
+        return ''.join(parts)
 
     @property
-    @abstractmethod
     def file_suffix(self):
         """Return suffix of generated Asciidoctor files"""
         raise NotImplementedError
 
-    @abstractmethod
-    def api_name(self, spectype = None):
-        """Return API name"""
+    def api_name(self, spectype=None):
+        """Return API or specification name for citations in ref pages.
+
+        spectype is the spec this refpage is for.
+        'api' (the default value) is the main API Specification.
+        If an unrecognized spectype is given, returns None.
+
+        Must implement."""
         raise NotImplementedError
 
+    def should_insert_may_alias_macro(self, genOpts):
+        """Return true if we should insert a "may alias" macro in this file.
+
+        Only used by OpenXR right now."""
+        return False
+
+    @property
+    def command_prefix(self):
+        """Return the expected prefix of commands/functions.
+
+        Implemented in terms of api_prefix."""
+        if not self._command_prefix:
+            self._command_prefix = self.api_prefix[:].replace('_', '').lower()
+        return self._command_prefix
+
+    @property
+    def type_prefix(self):
+        """Return the expected prefix of type names.
+
+        Implemented in terms of command_prefix (and in turn, api_prefix)."""
+        if not self._type_prefix:
+            self._type_prefix = ''.join(
+                (self.command_prefix[0:1].upper(), self.command_prefix[1:]))
+        return self._type_prefix
+
     @property
-    @abstractmethod
     def api_prefix(self):
-        """Return API token prefix"""
+        """Return API token prefix.
+
+        Typically two uppercase letters followed by an underscore.
+
+        Must implement."""
         raise NotImplementedError
 
     @property
-    @abstractmethod
     def api_version_prefix(self):
-        """Return API core version token prefix"""
-        raise NotImplementedError
+        """Return API core version token prefix.
+
+        Implemented in terms of api_prefix.
+
+        May override."""
+        return self.api_prefix + 'VERSION_'
 
     @property
-    @abstractmethod
     def KHR_prefix(self):
-        """Return extension name prefix for KHR extensions"""
-        raise NotImplementedError
+        """Return extension name prefix for KHR extensions.
+
+        Implemented in terms of api_prefix.
+
+        May override."""
+        return self.api_prefix + 'KHR_'
 
     @property
-    @abstractmethod
     def EXT_prefix(self):
-        """Return extension name prefix for EXT extensions"""
-        raise NotImplementedError
+        """Return extension name prefix for EXT extensions.
+
+        Implemented in terms of api_prefix.
+
+        May override."""
+        return self.api_prefix + 'EXT_'
+
+    def writeFeature(self, featureExtraProtect, filename):
+        """Return True if OutputGenerator.endFeature should write this feature.
+
+        Defaults to always True.
+        Used in COutputGenerator.
+
+        May override."""
+        return True
+
+    def requires_error_validation(self, return_type):
+        """Return True if the return_type element is an API result code
+        requiring error validation.
+
+        Defaults to always False.
+
+        May override."""
+        return False
+
+    @property
+    def required_errors(self):
+        """Return a list of required error codes for validation.
+
+        Defaults to an empty list.
+
+        May override."""
+        return []
+
+    def is_voidpointer_alias(self, tag, text, tail):
+        """Return True if the declaration components (tag,text,tail) of an
+        element represents a void * type.
+
+        Defaults to a reasonable implementation.
+
+        May override."""
+        return tag == 'type' and text == 'void' and tail.startswith('*')
+
+    def make_voidpointer_alias(self, tail):
+        """Reformat a void * declaration to include the API alias macro.
+
+        Defaults to a no-op.
+
+        Must override if you actually want to use this feature in your project."""
+        return tail
+
+    def category_requires_validation(self, category):
+        """Return True if the given type 'category' always requires validation.
+
+        Defaults to a reasonable implementation.
+
+        May override."""
+        return category in CATEGORIES_REQUIRING_VALIDATION
+
+    def type_always_valid(self, typename):
+        """Return True if the given type name is always valid (never requires validation).
+
+        This is for things like integers.
+
+        Defaults to a reasonable implementation.
+
+        May override."""
+        return typename in TYPES_KNOWN_ALWAYS_VALID
diff --git a/registry/generator.py b/registry/generator.py
index ba21e5d..1e4be14 100644
--- a/registry/generator.py
+++ b/registry/generator.py
@@ -18,14 +18,20 @@ from __future__ import unicode_literals
 
 import io
 import os
-import re
 import pdb
+import re
 import sys
-from pathlib import Path
+try:
+    from pathlib import Path
+except ImportError:
+    from pathlib2 import Path
+
+from spec_tools.util import getElemName, getElemType
 
-def write( *args, **kwargs ):
-    file = kwargs.pop('file',sys.stdout)
-    end = kwargs.pop('end','\n')
+
+def write(*args, **kwargs):
+    file = kwargs.pop('file', sys.stdout)
+    end = kwargs.pop('end', '\n')
     file.write(' '.join(str(arg) for arg in args))
     file.write(end)
 
@@ -37,6 +43,17 @@ def noneStr(s):
         return s
     return ""
 
+# noneInt - returns string argument as an integer, or default if argument is
+# None.
+# Used in converting etree Elements into integers.
+#   s - string to convert
+#   default - default value
+def noneInt(s, default = 0):
+    if s:
+        return int(s)
+    else:
+        return default
+
 # enquote - returns string argument with surrounding quotes,
 #   for serialization into Python code.
 def enquote(s):
@@ -44,7 +61,7 @@ def enquote(s):
         return "'{}'".format(s)
     return None
 
-# Primary sort key for regSortFeatures.
+# 1st sort key for regSortFeatures.
 # Sorts by category of the feature name string:
 #   Core API features (those defined with a <feature> tag)
 #   ARB/KHR/OES (Khronos extensions)
@@ -60,29 +77,31 @@ def regSortCategoryKey(feature):
 
     return 2
 
-# Secondary sort key for regSortFeatures.
-# Sorts by extension name.
-def regSortNameKey(feature):
-    return feature.name
+# 2nd sort key for regSortFeatures.
+# Sorts by sortorder attribute
+def regSortOrderKey(feature):
+    return feature.sortorder
 
-# Second sort key for regSortFeatures.
+# 3rd sort key for regSortFeatures.
 # Sorts by feature version. <extension> elements all have version number "0"
 def regSortFeatureVersionKey(feature):
     return float(feature.versionNumber)
 
-# Tertiary sort key for regSortFeatures.
+# 4th sort key for regSortFeatures.
 # Sorts by extension number. <feature> elements all have extension number 0.
 def regSortExtensionNumberKey(feature):
     return int(feature.number)
 
 # regSortFeatures - default sort procedure for features.
-# Sorts by primary key of feature category ('feature' or 'extension')
+# Sorts by primary key of feature category ('feature', or extension tag)
+#   then by sort order within the category
 #   then by version number (for features)
 #   then by extension number (for extensions)
 def regSortFeatures(featureList):
-    featureList.sort(key = regSortExtensionNumberKey)
-    featureList.sort(key = regSortFeatureVersionKey)
-    featureList.sort(key = regSortCategoryKey)
+    featureList.sort(key=regSortExtensionNumberKey)
+    featureList.sort(key=regSortFeatureVersionKey)
+    featureList.sort(key=regSortOrderKey)
+    featureList.sort(key=regSortCategoryKey)
 
 # GeneratorOptions - base class for options used during header production
 # These options are target language independent, and used by
@@ -114,26 +133,27 @@ def regSortFeatures(featureList):
 #     deciding which interfaces to generate).
 #   sortProcedure - takes a list of FeatureInfo objects and sorts
 #     them in place to a preferred order in the generated output.
-#     Default is core API versions, ARB/KHR/OES extensions, all
-#     other extensions, alphabetically within each group.
+#     Default is core API versions, ARB/KHR/OES extensions, all other
+#     extensions, by core API version number or extension number in
+#     each group.
 # The regex patterns can be None or empty, in which case they match
 #   nothing.
 class GeneratorOptions:
     """Represents options during header production from an API registry"""
 
     def __init__(self,
-                 conventions = None,
-                 filename = None,
-                 directory = '.',
-                 apiname = None,
-                 profile = None,
-                 versions = '.*',
-                 emitversions = '.*',
-                 defaultExtensions = None,
-                 addExtensions = None,
-                 removeExtensions = None,
-                 emitExtensions = None,
-                 sortProcedure = regSortFeatures):
+                 conventions=None,
+                 filename=None,
+                 directory='.',
+                 apiname=None,
+                 profile=None,
+                 versions='.*',
+                 emitversions='.*',
+                 defaultExtensions=None,
+                 addExtensions=None,
+                 removeExtensions=None,
+                 emitExtensions=None,
+                 sortProcedure=regSortFeatures):
         self.conventions       = conventions
         self.filename          = filename
         self.directory         = directory
@@ -202,19 +222,19 @@ class OutputGenerator:
 
     # categoryToPath - map XML 'category' to include file directory name
     categoryToPath = {
-        'bitmask'      : 'flags',
-        'enum'         : 'enums',
-        'funcpointer'  : 'funcpointers',
-        'handle'       : 'handles',
-        'define'       : 'defines',
-        'basetype'     : 'basetypes',
+        'bitmask': 'flags',
+        'enum': 'enums',
+        'funcpointer': 'funcpointers',
+        'handle': 'handles',
+        'define': 'defines',
+        'basetype': 'basetypes',
     }
 
     # Constructor
     def __init__(self,
-                 errFile = sys.stderr,
-                 warnFile = sys.stderr,
-                 diagFile = sys.stdout):
+                 errFile=sys.stderr,
+                 warnFile=sys.stderr,
+                 diagFile=sys.stdout):
         self.outFile = None
         self.errFile = errFile
         self.warnFile = warnFile
@@ -224,7 +244,7 @@ class OutputGenerator:
         self.genOpts = None
         self.registry = None
         # Used for extension enum value generation
-        self.extBase      = 1000000000
+        self.extBase = 1000000000
         self.extBlockSize = 1000
         self.madeDirs = {}
 
@@ -292,21 +312,21 @@ class OutputGenerator:
             bitpos = int(value, 0)
             numVal = 1 << bitpos
             value = '0x%08x' % numVal
-            if( bitpos >= 32 ):
+            if bitpos >= 32:
                 value = value + 'ULL'
             self.logMsg('diag', 'Enum', name, '-> bitpos [', numVal, ',', value, ']')
             return [numVal, value]
         if 'offset' in elem.keys():
             # Obtain values in the mapping from the attributes
             enumNegative = False
-            offset = int(elem.get('offset'),0)
-            extnumber = int(elem.get('extnumber'),0)
+            offset = int(elem.get('offset'), 0)
+            extnumber = int(elem.get('extnumber'), 0)
             extends = elem.get('extends')
             if 'dir' in elem.keys():
                 enumNegative = True
             self.logMsg('diag', 'Enum', name, 'offset =', offset,
-                'extnumber =', extnumber, 'extends =', extends,
-                'enumNegative =', enumNegative)
+                        'extnumber =', extnumber, 'extends =', extends,
+                        'enumNegative =', enumNegative)
             # Now determine the actual enumerant value, as defined
             # in the "Layers and Extensions" appendix of the spec.
             numVal = self.extBase + (extnumber - 1) * self.extBlockSize + offset
@@ -343,7 +363,7 @@ class OutputGenerator:
                 # happens when defining the same enum conditionally in
                 # several extension blocks.
                 if (strVal2 == strVal or (numVal is not None and
-                    numVal == numVal2)):
+                                          numVal == numVal2)):
                     True
                     # self.logMsg('info', 'checkDuplicateEnums: Duplicate enum (' + name +
                     #             ') found with the same value:' + strVal)
@@ -361,14 +381,14 @@ class OutputGenerator:
 
                 try:
                     self.logMsg('warn', 'Two enums found with the same value: '
-                             + name + ' = ' + name2.get('name') + ' = ' + strVal)
+                                + name + ' = ' + name2.get('name') + ' = ' + strVal)
                 except:
                     pdb.set_trace()
 
             # Track this enum to detect followon duplicates
-            nameMap[name] = [ elem, numVal, strVal ]
+            nameMap[name] = [elem, numVal, strVal]
             if numVal is not None:
-                valueMap[numVal] = [ elem, numVal, strVal ]
+                valueMap[numVal] = [elem, numVal, strVal]
 
             # Add this enum to the list
             stripped.append(elem)
@@ -382,7 +402,7 @@ class OutputGenerator:
         groupElem = groupinfo.elem
 
         if self.genOpts.conventions.constFlagBits and groupElem.get('type') == 'bitmask':
-            return self.buildEnumCDecl_Bitmask( groupinfo, groupName)
+            return self.buildEnumCDecl_Bitmask(groupinfo, groupName)
         else:
             return self.buildEnumCDecl_Enum(expand, groupinfo, groupName)
 
@@ -403,7 +423,7 @@ class OutputGenerator:
             # Should catch exceptions here for more complex constructs. Not yet.
             (_, strVal) = self.enumToValue(elem, True)
             name = elem.get('name')
-            body += "static const " + flagTypeName + " " + name + " = " + strVal + ";\n"
+            body += "static const {} {} = {};\n".format(flagTypeName, name, strVal)
 
         # Postfix
 
@@ -415,17 +435,17 @@ class OutputGenerator:
 
         # Break the group name into prefix and suffix portions for range
         # enum generation
-        expandName = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2',groupName).upper()
+        expandName = re.sub(r'([0-9a-z_])([A-Z0-9])', r'\1_\2', groupName).upper()
         expandPrefix = expandName
         expandSuffix = ''
-        expandSuffixMatch = re.search(r'[A-Z][A-Z]+$',groupName)
+        expandSuffixMatch = re.search(r'[A-Z][A-Z]+$', groupName)
         if expandSuffixMatch:
             expandSuffix = '_' + expandSuffixMatch.group()
             # Strip off the suffix from the prefix
             expandPrefix = expandName.rsplit(expandSuffix, 1)[0]
 
         # Prefix
-        body = "typedef enum " + groupName + " {\n"
+        body = ["typedef enum %s {" % groupName]
 
         # @@ Should use the type="bitmask" attribute instead
         isEnum = ('FLAG_BITS' not in expandPrefix)
@@ -447,22 +467,22 @@ class OutputGenerator:
         # them following the numeric values, to allow for aliases.
         # NOTE: this doesn't do a topological sort yet, so aliases of
         # aliases can still get in the wrong order.
-        aliasText = ""
+        aliasText = []
 
         for elem in enums:
             # Convert the value to an integer and use that to track min/max.
             # Values of form -(number) are accepted but nothing more complex.
             # Should catch exceptions here for more complex constructs. Not yet.
-            (numVal,strVal) = self.enumToValue(elem, True)
+            (numVal, strVal) = self.enumToValue(elem, True)
             name = elem.get('name')
 
             # Extension enumerants are only included if they are required
             if self.isEnumRequired(elem):
-                decl = "    " + name + " = " + strVal + ",\n"
+                decl = "    {} = {},".format(name, strVal)
                 if numVal is not None:
-                    body += decl
+                    body.append(decl)
                 else:
-                    aliasText += decl
+                    aliasText.append(decl)
 
             # Don't track min/max for non-numbers (numVal is None)
             if isEnum and numVal is not None and elem.get('extends') is None:
@@ -477,20 +497,21 @@ class OutputGenerator:
                     maxValue = numVal
 
         # Now append the non-numeric enumerant values
-        body += aliasText
+        body.extend(aliasText)
 
         # Generate min/max value tokens and a range-padding enum. Need some
         # additional padding to generate correct names...
         if isEnum and expand:
-            body += "    " + expandPrefix + "_BEGIN_RANGE" + expandSuffix + " = " + minName + ",\n"
-            body += "    " + expandPrefix + "_END_RANGE" + expandSuffix + " = " + maxName + ",\n"
-            body += "    " + expandPrefix + "_RANGE_SIZE" + expandSuffix + " = (" + maxName + " - " + minName + " + 1),\n"
+            body.extend(("    {}_BEGIN_RANGE{} = {},".format(expandPrefix, expandSuffix, minName),
+                         "    {}_END_RANGE{} = {},".format(
+                             expandPrefix, expandSuffix, maxName),
+                         "    {}_RANGE_SIZE{} = ({} - {} + 1),".format(expandPrefix, expandSuffix, maxName, minName)))
 
-        # Always generate this to make sure the enumerated type is 32 bits
-        body += "    " + expandPrefix + "_MAX_ENUM" + expandSuffix + " = 0x7FFFFFFF\n"
+        body.append("    {}_MAX_ENUM{} = 0x7FFFFFFF".format(
+            expandPrefix, expandSuffix))
 
         # Postfix
-        body += "} " + groupName + ";"
+        body.append("} %s;" % groupName)
 
         # Determine appropriate section for this declaration
         if groupElem.get('type') == 'bitmask':
@@ -498,7 +519,7 @@ class OutputGenerator:
         else:
             section = 'group'
 
-        return (section, body)
+        return (section, '\n'.join(body))
 
     def makeDir(self, path):
         self.logMsg('diag', 'OutputGenerator::makeDir(' + path + ')')
@@ -511,6 +532,10 @@ class OutputGenerator:
 
     def beginFile(self, genOpts):
         self.genOpts = genOpts
+        self.should_insert_may_alias_macro = \
+            self.genOpts.conventions.should_insert_may_alias_macro(self.genOpts)
+
+        self.conventions = genOpts.conventions
 
         # Open specified output file. Not done in constructor since a
         # Generator can be used without writing to a file.
@@ -600,13 +625,14 @@ class OutputGenerator:
     # aligncol - if non-zero, attempt to align the nested <name> element
     #   at this column
     def makeCParamDecl(self, param, aligncol):
-        paramdecl = '    ' + noneStr(param.text)
+        indent = '    '
+        paramdecl = indent + noneStr(param.text)
         for elem in param:
             text = noneStr(elem.text)
             tail = noneStr(elem.tail)
 
-            if self.genOpts.conventions.is_voidpointer_alias(elem.tag, text, tail):
-                # OpenXR-specific macro insertion
+            if self.should_insert_may_alias_macro and self.genOpts.conventions.is_voidpointer_alias(elem.tag, text, tail):
+                # OpenXR-specific macro insertion - but not in apiinc for the spec
                 tail = self.genOpts.conventions.make_voidpointer_alias(tail)
             if elem.tag == 'name' and aligncol > 0:
                 self.logMsg('diag', 'Aligning parameter', elem.text, 'to column', self.genOpts.alignFuncParam)
@@ -616,17 +642,22 @@ class OutputGenerator:
                 # This works around a problem where very long type names -
                 # longer than the alignment column - would run into the tail
                 # text.
-                paramdecl = paramdecl.ljust(aligncol-1) + ' '
+                paramdecl = paramdecl.ljust(aligncol - 1) + ' '
                 newLen = len(paramdecl)
                 self.logMsg('diag', 'Adjust length of parameter decl from', oldLen, 'to', newLen, ':', paramdecl)
             paramdecl += text + tail
+        if aligncol == 0:
+            # Squeeze out multiple spaces other than the identation
+            paramdecl = indent + ' '.join(paramdecl.split())
         return paramdecl
 
-    # getCParamTypeLength - return the length of the type field is an indented, formatted
-    # declaration for a <param> or <member> block (e.g. function parameter
-    # or structure/union member).
+    # getCParamTypeLength - return the length of the type field in an
+    # indented, formatted declaration for a <param> or <member> block (e.g.
+    # function parameter or structure/union member). This relies on the
+    # presence of the <name> tag; if not present, return zero.
     # param - Element (<param> or <member>) to identify
     def getCParamTypeLength(self, param):
+        newLen = 0
         paramdecl = '    ' + noneStr(param.text)
         for elem in param:
             text = noneStr(elem.text)
@@ -643,17 +674,106 @@ class OutputGenerator:
 
         return newLen
 
+    def getMaxCParamTypeLength(self, info):
+        """Return the length of the longest type field for a member/parameter.
+
+        info - TypeInfo or CommandInfo.
+        """
+        lengths = (self.getCParamTypeLength(member)
+                   for member in info.getMembers())
+        return max(lengths)
+
+    def getHandleParent(self, typename):
+        """Get the parent of a handle object."""
+        info = self.registry.typedict.get(typename)
+        if info is None:
+            return None
+
+        elem = info.elem
+        if elem is not None:
+            return elem.get('parent')
+
+        return None
+
+    def iterateHandleAncestors(self, typename):
+        """Iterate through the ancestors of a handle type."""
+        current = self.getHandleParent(typename)
+        while current is not None:
+            yield current
+            current = self.getHandleParent(current)
+
+    def getHandleAncestors(self, typename):
+        """Get the ancestors of a handle object."""
+        return list(self.iterateHandleAncestors(typename))
+
+    def getTypeCategory(self, typename):
+        """Get the category of a type."""
+        info = self.registry.typedict.get(typename)
+        if info is None:
+            return None
+
+        elem = info.elem
+        if elem is not None:
+            return elem.get('category')
+        return None
+
+    def isStructAlwaysValid(self, structname):
+        """Try to do check if a structure is always considered valid (i.e. there's no rules to its acceptance)."""
+        # A conventions object is required for this call.
+        if not self.conventions:
+            raise RuntimeError("To use isStructAlwaysValid, be sure your options include a Conventions object.")
+
+        if self.conventions.type_always_valid(structname):
+            return True
+
+        category = self.getTypeCategory(structname)
+        if self.conventions.category_requires_validation(category):
+            return False
+
+        info = self.registry.typedict.get(structname)
+        assert(info is not None)
+
+        members = info.getMembers()
+
+        for member in members:
+            member_name = getElemName(member)
+            if member_name in (self.conventions.structtype_member_name,
+                               self.conventions.nextpointer_member_name):
+                return False
+
+            if member.get('noautovalidity'):
+                return False
+
+            member_type = getElemType(member)
+
+            if member_type in ('void', 'char') or self.paramIsArray(member) or self.paramIsPointer(member):
+                return False
+
+            if self.conventions.type_always_valid(member_type):
+                continue
+
+            member_category = self.getTypeCategory(member_type)
+
+            if self.conventions.category_requires_validation(member_category):
+                return False
+
+            if member_category in ('struct', 'union'):
+                if self.isStructAlwaysValid(member_type) is False:
+                    return False
+
+        return True
+
     # isEnumRequired(elem) - return True if this <enum> element is
     # required, False otherwise
     # elem - <enum> element to test
     def isEnumRequired(self, elem):
         required = elem.get('required') is not None
         self.logMsg('diag', 'isEnumRequired:', elem.get('name'),
-            '->', required)
+                    '->', required)
         return required
 
-        #@@@ This code is overridden by equivalent code now run in
-        #@@@ Registry.generateFeature
+        # @@@ This code is overridden by equivalent code now run in
+        # @@@ Registry.generateFeature
 
         required = False
 
@@ -704,6 +824,12 @@ class OutputGenerator:
             else:
                 pdecl += text + tail
                 tdecl += text + tail
+
+        if self.genOpts.alignFuncParam == 0:
+            # Squeeze out multiple spaces - there is no indentation
+            pdecl = ' '.join(pdecl.split())
+            tdecl = ' '.join(tdecl.split())
+
         # Now add the parameter declaration list, which is identical
         # for prototypes and typedefs. Concatenate all the text from
         # a <param> node without the tags. No tree walking required
@@ -729,7 +855,7 @@ class OutputGenerator:
         else:
             paramdecl += 'void'
         paramdecl += ");"
-        return [ pdecl + indentdecl, tdecl + paramdecl ]
+        return [pdecl + indentdecl, tdecl + paramdecl]
 
     def newline(self):
         write('', file=self.outFile)
diff --git a/registry/genvk.py b/registry/genvk.py
index 6355f86..84cad3c 100644..100755
--- a/registry/genvk.py
+++ b/registry/genvk.py
@@ -48,12 +48,14 @@ def endTimer(timeit, msg):
         write(msg, endTime - startTime, file=sys.stderr)
         startTime = None
 
-# Turn a list of strings into a regexp string matching exactly those strings
-def makeREstring(list, default = None):
-    if len(list) > 0 or default is None:
-        return '^(' + '|'.join(list) + ')$'
-    else:
-        return default
+
+def makeREstring(strings, default=None, strings_are_regex=False):
+    """Turn a list of strings into a regexp string matching exactly those strings."""
+    if strings or default is None:
+        if not strings_are_regex:
+            strings = (re.escape(s) for s in strings)
+        return '^(' + '|'.join(strings) + ')$'
+    return default
 
 # Returns a directory of [ generator function, generator options ] indexed
 # by specified short names. The generator options incorporate the following
@@ -275,8 +277,10 @@ def makeGenOpts(args):
 
         allPlatformExtensions += platform[1]
 
-        addPlatformExtensionsRE = makeREstring(platform[1] + platform[2])
-        emitPlatformExtensionsRE = makeREstring(platform[1])
+        addPlatformExtensionsRE = makeREstring(
+            platform[1] + platform[2], strings_are_regex=True)
+        emitPlatformExtensionsRE = makeREstring(
+            platform[1], strings_are_regex=True)
 
         opts = CGeneratorOptions(
             conventions       = conventions,
@@ -312,7 +316,8 @@ def makeGenOpts(args):
     # It removes all platform extensions (from the platform headers options
     # constructed above) as well as any explicitly specified removals.
 
-    removeExtensionsPat = makeREstring(allPlatformExtensions + removeExtensions, None)
+    removeExtensionsPat = makeREstring(
+        allPlatformExtensions + removeExtensions, None, strings_are_regex=True)
 
     genOpts['vulkan_core.h'] = [
           COutputGenerator,
@@ -533,7 +538,8 @@ if __name__ == '__main__':
     if args.debug:
         pdb.run('genTarget(args)')
     elif args.profile:
-        import cProfile, pstats
+        import cProfile
+        import pstats
         cProfile.run('genTarget(args)', 'profile.txt')
         p = pstats.Stats('profile.txt')
         p.strip_dirs().sort_stats('time').print_stats(50)
diff --git a/registry/reg.py b/registry/reg.py
index 982c04c..27164c8 100644..100755
--- a/registry/reg.py
+++ b/registry/reg.py
@@ -19,7 +19,8 @@ import re
 import sys
 import xml.etree.ElementTree as etree
 from collections import defaultdict, namedtuple
-from generator import OutputGenerator, write
+from generator import OutputGenerator, write, noneInt
+import pdb
 
 # matchAPIProfile - returns whether an API and profile
 #   being generated matches an element's profile
@@ -70,6 +71,12 @@ def matchAPIProfile(api, profile, elem):
             return False
     return True
 
+# Print all the keys in an Element - only for diagnostics
+# def printKeys(msg, elem):
+#     print('printKeys:', msg, file=sys.stderr)
+#     for key in elem.keys():
+#         print('    {} -> {}'.format(key, elem.get(key)), file=sys.stderr)
+
 # BaseInfo - base class for information about a registry feature
 # (type/group/enum/command/API/extension).
 #   required - should this feature be defined during header generation
@@ -89,26 +96,41 @@ class BaseInfo:
     def resetState(self):
         self.required = False
         self.declared = False
-    def compareElem(self, info):
-        # Just compares the tag and attributes.
-        # @@ This should be virtualized. In particular, comparing <enum>
-        # tags requires special-casing on the attributes, as 'extnumber' is
-        # only relevant when 'offset' is present.
-        selfKeys = sorted(self.elem.keys())
-        infoKeys = sorted(info.elem.keys())
-
-        if selfKeys != infoKeys:
+    def compareKeys(self, info, key, required = False):
+        # Return True if self.elem and info.elem have the same attribute
+        # value for key.
+        # If 'required' is not True, also returns True if neither element
+        # has an attribute value for key.
+        if required and key not in self.elem.keys():
             return False
-
-        # Ignore value of 'extname' and 'extnumber', as these will inherently
-        # be different when redefining the same interface in different feature
-        # and/or extension blocks.
-        for key in selfKeys:
-            if (key != 'extname' and key != 'extnumber' and
-                (self.elem.get(key) != info.elem.get(key))):
+        return self.elem.get(key) == info.elem.get(key)
+    def compareElem(self, info, infoName):
+        # Return True if self.elem and info.elem have the same definition
+        # info - the other object
+        # infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension'
+
+        if infoName == 'enum':
+            if self.compareKeys(info, 'extends'):
+                # Either both extend the same type, or no type
+                if (self.compareKeys(info, 'value', required = True) or
+                    self.compareKeys(info, 'bitpos', required = True)):
+                    # If both specify the same value or bit position,
+                    # they're equal
+                    return True
+                elif (self.compareKeys(info, 'extends') and
+                      self.compareKeys(info, 'extnumber') and
+                      self.compareKeys(info, 'offset') and
+                      self.compareKeys(info, 'dir')):
+                    # If both specify the same relative offset, they're equal
+                    return True
+                else:
+                    return False
+            else:
+                # The same enum can't extend two different types
                 return False
-
-        return True
+        else:
+            # Non-<enum>s should never be redefined
+            return False
 
 # TypeInfo - registry information about a type. No additional state
 #   beyond BaseInfo is required.
@@ -118,6 +140,10 @@ class TypeInfo(BaseInfo):
         BaseInfo.__init__(self, elem)
         self.additionalValidity = []
         self.removedValidity = []
+
+    def getMembers(self):
+        return self.elem.findall('member')
+
     def resetState(self):
         BaseInfo.resetState(self)
         self.additionalValidity = []
@@ -148,6 +174,10 @@ class CmdInfo(BaseInfo):
         BaseInfo.__init__(self, elem)
         self.additionalValidity = []
         self.removedValidity = []
+
+    def getParams(self):
+        return self.elem.findall('param')
+
     def resetState(self):
         BaseInfo.resetState(self)
         self.additionalValidity = []
@@ -156,29 +186,34 @@ class CmdInfo(BaseInfo):
 # FeatureInfo - registry information about an API <feature>
 # or <extension>
 #   name - feature name string (e.g. 'VK_KHR_surface')
-#   version - feature version number (e.g. 1.2). <extension>
+#   category - category, e.g. VERSION or khr/vendor tag
+#   version - feature name string
 #     features are unversioned and assigned version number 0.
 #     ** This is confusingly taken from the 'number' attribute of <feature>.
 #        Needs fixing.
+#   versionNumber - API version number, taken from the 'number' attribute
+#     of <feature>. Extensions do not have API version numbers and are
+#     assigned number 0.
 #   number - extension number, used for ordering and for
 #     assigning enumerant offsets. <feature> features do
 #     not have extension numbers and are assigned number 0.
-#   category - category, e.g. VERSION or khr/vendor tag
 #   emit - has this feature been defined already?
 class FeatureInfo(BaseInfo):
     """Represents the state of an API feature (version/extension)"""
     def __init__(self, elem):
         BaseInfo.__init__(self, elem)
         self.name = elem.get('name')
-        # Determine element category (vendor). Only works
-        # for <extension> elements.
+        self.sortorder = noneInt(elem.get('sortorder'), 0)
+
         if elem.tag == 'feature':
+            # Element category (vendor) is meaningless for <feature>
             self.category = 'VERSION'
             self.version = elem.get('name')
             self.versionNumber = elem.get('number')
             self.number = "0"
             self.supported = None
         else:
+            # Extract vendor portion of VK_<vendor>_<name>
             self.category = self.name.split('_', 2)[1]
             self.version = "0"
             self.versionNumber = "0"
@@ -251,6 +286,7 @@ class Registry:
         self.emitFeatures = False
         self.breakPat     = None
         # self.breakPat     = re.compile('VkFenceImportFlagBits.*')
+        self.filename     = None
 
     def loadElementTree(self, tree):
         """Load ElementTree into a Registry object and parse it"""
@@ -259,6 +295,7 @@ class Registry:
 
     def loadFile(self, file):
         """Load an API registry XML file into a Registry object and parse it"""
+        self.filename = file
         self.tree = etree.parse(file)
         self.parseTree()
 
@@ -285,12 +322,14 @@ class Registry:
         else:
             key = elem.get('name')
         if key in dictionary:
-            if not dictionary[key].compareElem(info):
+            if not dictionary[key].compareElem(info, infoName):
                 self.gen.logMsg('warn', 'Attempt to redefine', key,
-                                'with different value (this may be benign)')
-            #else:
-            #    self.gen.logMsg('warn', 'Benign redefinition of', key,
-            #                    'with identical value')
+                                '(this should not happen)')
+                # printKeys('old element', dictionary[key].elem)
+                # printKeys('new element', info.elem)
+            else:
+                # Benign redefinition - intentional cases exist.
+                True
         else:
             dictionary[key] = info
 
@@ -450,7 +489,11 @@ class Registry:
                             gi.elem.append(enum)
                             # Remove element from parent <require> tag
                             # This should be a no-op in lxml.etree
-                            elem.remove(enum)
+                            try:
+                                elem.remove(enum)
+                            except ValueError:
+                                # Must be lxml.etree
+                                pass
                         else:
                             self.gen.logMsg('warn', 'NO matching group',
                                 groupName, 'for enum', enum.get('name'), 'found.')
@@ -500,7 +543,11 @@ class Registry:
                             gi.elem.append(enum)
                             # Remove element from parent <require> tag
                             # This should be a no-op in lxml.etree
-                            elem.remove(enum)
+                            try:
+                                elem.remove(enum)
+                            except ValueError:
+                                # Must be lxml.etree
+                                pass
                         else:
                             self.gen.logMsg('warn', 'NO matching group',
                                 groupName, 'for enum', enum.get('name'), 'found.')
@@ -1035,7 +1082,7 @@ class Registry:
                 self.gen.logMsg('diag', 'NOT including extension',
                     extName, '(does not match api attribute or explicitly requested extensions)')
 
-        # Sort the extension features list, if a sort procedure is defined
+        # Sort the features list, if a sort procedure is defined
         if self.genOpts.sortProcedure:
             self.genOpts.sortProcedure(features)
 
diff --git a/registry/spec_tools/util.py b/registry/spec_tools/util.py
new file mode 100644
index 0000000..2463290
--- /dev/null
+++ b/registry/spec_tools/util.py
@@ -0,0 +1,68 @@
+"""Utility functions not closely tied to other spec_tools types."""
+# Copyright (c) 2018-2019 Collabora, Ltd.
+# Copyright (c) 2013-2019 The Khronos Group Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def getElemName(elem, default=None):
+    """Get the name associated with an element, either a name child or name attribute."""
+    name_elem = elem.find('name')
+    if name_elem is not None:
+        return name_elem.text
+    # Fallback if there is no child.
+    return elem.get('name', default)
+
+
+def getElemType(elem, default=None):
+    """Get the type associated with an element, either a type child or type attribute."""
+    type_elem = elem.find('type')
+    if type_elem is not None:
+        return type_elem.text
+    # Fallback if there is no child.
+    return elem.get('type', default)
+
+
+def findFirstWithPredicate(collection, pred):
+    """Return the first element that satisfies the predicate, or None if none exist.
+
+    NOTE: Some places where this is used might be better served by changing to a dictionary.
+    """
+    for elt in collection:
+        if pred(elt):
+            return elt
+    return None
+
+
+def findNamedElem(elems, name):
+    """Traverse a collection of elements with 'name' nodes or attributes, looking for and returning one with the right name.
+
+    NOTE: Many places where this is used might be better served by changing to a dictionary.
+    """
+    return findFirstWithPredicate(elems, lambda elem: getElemName(elem) == name)
+
+
+def findTypedElem(elems, typename):
+    """Traverse a collection of elements with 'type' nodes or attributes, looking for and returning one with the right typename.
+
+    NOTE: Many places where this is used might be better served by changing to a dictionary.
+    """
+    return findFirstWithPredicate(elems, lambda elem: getElemType(elem) == typename)
+
+
+def findNamedObject(collection, name):
+    """Traverse a collection of elements with 'name' attributes, looking for and returning one with the right name.
+
+    NOTE: Many places where this is used might be better served by changing to a dictionary.
+    """
+    return findFirstWithPredicate(collection, lambda elt: elt.name == name)
diff --git a/registry/validusage.json b/registry/validusage.json
index 18d13e7..fed2e68 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.1.114",
-    "comment": "from git branch: github-master commit: 7eb07044df67e19e768080c7f378fc0938ead346",
-    "date": "2019-07-08 03:11:46Z"
+    "api version": "1.1.121",
+    "comment": "from git branch: github-master commit: 59750fe4c72a9295a94e22474060d3a1635e92c8",
+    "date": "2019-08-25 10:57:34Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -214,7 +214,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=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingPropertiesEXT\">VkPhysicalDeviceDescriptorIndexingPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverPropertiesKHR\">VkPhysicalDeviceDriverPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsPropertiesKHR\">VkPhysicalDeviceFloatControlsPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapPropertiesEXT\">VkPhysicalDeviceFragmentDensityMapPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceIDProperties\">VkPhysicalDeviceIDProperties</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockPropertiesEXT\">VkPhysicalDeviceInlineUniformBlockPropertiesEXT</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=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT\">VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceShaderCorePropertiesAMD\">VkPhysicalDeviceShaderCorePropertiesAMD</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsPropertiesNV\">VkPhysicalDeviceShaderSMBuiltinsPropertiesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImagePropertiesNV\">VkPhysicalDeviceShadingRateImagePropertiesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupProperties\">VkPhysicalDeviceSubgroupProperties</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</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=\"#VkPhysicalDeviceDepthStencilResolvePropertiesKHR\">VkPhysicalDeviceDepthStencilResolvePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingPropertiesEXT\">VkPhysicalDeviceDescriptorIndexingPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDiscardRectanglePropertiesEXT\">VkPhysicalDeviceDiscardRectanglePropertiesEXT</a>, <a href=\"#VkPhysicalDeviceDriverPropertiesKHR\">VkPhysicalDeviceDriverPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceExternalMemoryHostPropertiesEXT\">VkPhysicalDeviceExternalMemoryHostPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceFloatControlsPropertiesKHR\">VkPhysicalDeviceFloatControlsPropertiesKHR</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=\"#VkPhysicalDevicePointClippingProperties\">VkPhysicalDevicePointClippingProperties</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryProperties\">VkPhysicalDeviceProtectedMemoryProperties</a>, <a href=\"#VkPhysicalDevicePushDescriptorPropertiesKHR\">VkPhysicalDevicePushDescriptorPropertiesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPropertiesNV\">VkPhysicalDeviceRayTracingPropertiesNV</a>, <a href=\"#VkPhysicalDeviceSampleLocationsPropertiesEXT\">VkPhysicalDeviceSampleLocationsPropertiesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT\">VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT</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=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>"
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique",
@@ -362,7 +362,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=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice8BitStorageFeaturesKHR\">VkPhysicalDevice8BitStorageFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</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=\"#VkPhysicalDeviceDescriptorIndexingFeaturesEXT\">VkPhysicalDeviceDescriptorIndexingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFloat16Int8FeaturesKHR\">VkPhysicalDeviceFloat16Int8FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeaturesEXT\">VkPhysicalDeviceHostQueryResetFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeaturesKHR\">VkPhysicalDeviceImagelessFramebufferFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeaturesEXT\">VkPhysicalDeviceScalarBlockLayoutFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64FeaturesKHR\">VkPhysicalDeviceShaderAtomicInt64FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2INTEL\">VkPhysicalDeviceShaderIntegerFunctions2INTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR\">VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeaturesKHR\">VkPhysicalDeviceVulkanMemoryModelFeaturesKHR</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=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice8BitStorageFeaturesKHR\">VkPhysicalDevice8BitStorageFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</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=\"#VkPhysicalDeviceDescriptorIndexingFeaturesEXT\">VkPhysicalDeviceDescriptorIndexingFeaturesEXT</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=\"#VkPhysicalDeviceHostQueryResetFeaturesEXT\">VkPhysicalDeviceHostQueryResetFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeaturesKHR\">VkPhysicalDeviceImagelessFramebufferFeaturesKHR</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=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeaturesEXT\">VkPhysicalDeviceScalarBlockLayoutFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64FeaturesKHR\">VkPhysicalDeviceShaderAtomicInt64FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8FeaturesKHR\">VkPhysicalDeviceShaderFloat16Int8FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR\">VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeaturesKHR\">VkPhysicalDeviceVulkanMemoryModelFeaturesKHR</a>, or <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>"
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-sType-unique",
@@ -717,6 +717,10 @@
         {
           "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 <code>VkCommandBuffer</code> 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>"
         }
       ]
     },
@@ -863,6 +867,14 @@
           "text": " If the <a href=\"#features-inheritedQueries\">inherited queries</a> feature is enabled, <code>queryFlags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkQueryControlFlagBits\">VkQueryControlFlagBits</a> values"
         },
         {
+          "vuid": "VUID-VkCommandBufferInheritanceInfo-queryFlags-02788",
+          "text": " If the <a href=\"#features-inheritedQueries\">inherited queries</a> feature is not enabled, <code>queryFlags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+        },
+        {
+          "vuid": "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789",
+          "text": " If the <a href=\"#features-pipelineStatisticsQuery\">pipeline statistics queries</a> feature is enabled, <code>pipelineStatistics</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkQueryPipelineStatisticFlagBits\">VkQueryPipelineStatisticFlagBits</a> values"
+        },
+        {
           "vuid": "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058",
           "text": " If the <a href=\"#features-pipelineStatisticsQuery\">pipeline statistics queries</a> feature is not enabled, <code>pipelineStatistics</code> <strong class=\"purple\">must</strong> be <code>0</code>"
         },
@@ -954,7 +966,7 @@
         },
         {
           "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-00068",
-          "text": " When a semaphore unsignal operation defined by any element of the <code>pWaitSemaphores</code> member of any element of <code>pSubmits</code> executes on <code>queue</code>, no other queue <strong class=\"purple\">must</strong> be waiting on the same semaphore."
+          "text": " When a semaphore unsignal operation defined by any element of the <code>pWaitSemaphores</code> member of any element of <code>pSubmits</code> executes on <code>queue</code>, there <strong class=\"purple\">must</strong> be no other queues waiting on the same semaphore."
         },
         {
           "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-00069",
@@ -3046,7 +3058,7 @@
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00838",
-          "text": " For any element of <code>pDependencies</code>, if the <code>dstSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, all stage flags included in the <code>dstStageMask</code> member of that dependency <strong class=\"purple\">must</strong> be a pipeline stage supported by the <a href=\"#synchronization-pipeline-stages-types\">pipeline</a> identified by the <code>pipelineBindPoint</code> member of the source subpass"
+          "text": " For any element of <code>pDependencies</code>, if the <code>dstSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, all stage flags included in the <code>dstStageMask</code> member of that dependency <strong class=\"purple\">must</strong> be a pipeline stage supported by the <a href=\"#synchronization-pipeline-stages-types\">pipeline</a> identified by the <code>pipelineBindPoint</code> member of the destination subpass"
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo-srcSubpass-02517",
@@ -3403,14 +3415,6 @@
     "VkSubpassDependency": {
       "core": [
         {
-          "vuid": "VUID-VkSubpassDependency-srcSubpass-00858",
-          "text": " If <code>srcSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not include <code>VK_PIPELINE_STAGE_HOST_BIT</code>"
-        },
-        {
-          "vuid": "VUID-VkSubpassDependency-dstSubpass-00859",
-          "text": " If <code>dstSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not include <code>VK_PIPELINE_STAGE_HOST_BIT</code>"
-        },
-        {
           "vuid": "VUID-VkSubpassDependency-srcStageMask-00860",
           "text": " If the <a href=\"#features-geometryShader\">geometry shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT</code>"
         },
@@ -3435,10 +3439,6 @@
           "text": " <code>srcSubpass</code> and <code>dstSubpass</code> <strong class=\"purple\">must</strong> not both be equal to <code>VK_SUBPASS_EXTERNAL</code>"
         },
         {
-          "vuid": "VUID-VkSubpassDependency-srcSubpass-01989",
-          "text": " If <code>srcSubpass</code> is equal to <code>dstSubpass</code>, <code>srcStageMask</code> and <code>dstStageMask</code> <strong class=\"purple\">must</strong> not set any bits that are neither <code>VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT</code>, nor one of the <a href=\"#synchronization-pipeline-stages-types\">graphics pipeline stages</a>"
-        },
-        {
           "vuid": "VUID-VkSubpassDependency-srcSubpass-00867",
           "text": " If <code>srcSubpass</code> is equal to <code>dstSubpass</code> and not all of the stages in <code>srcStageMask</code> and <code>dstStageMask</code> are <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stages</a>, the <a href=\"#synchronization-pipeline-stages-order\">logically latest</a> pipeline stage in <code>srcStageMask</code> <strong class=\"purple\">must</strong> be <a href=\"#synchronization-pipeline-stages-order\">logically earlier</a> than or equal to the <a href=\"#synchronization-pipeline-stages-order\">logically earliest</a> pipeline stage in <code>dstStageMask</code>"
         },
@@ -3560,11 +3560,11 @@
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054",
-          "text": " For any element of <code>pDependencies</code>, if the <code>srcSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, all stage flags included in the <code>srcStageMask</code> member of that dependency <strong class=\"purple\">must</strong> be a pipeline stage supported by the <a href=\"#synchronization-pipeline-stages-types\">pipeline</a> identified by the <code>pipelineBindPoint</code> member of the source subpass."
+          "text": " For any element of <code>pDependencies</code>, if the <code>srcSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, all stage flags included in the <code>srcStageMask</code> member of that dependency <strong class=\"purple\">must</strong> be a pipeline stage supported by the <a href=\"#synchronization-pipeline-stages-types\">pipeline</a> identified by the <code>pipelineBindPoint</code> member of the source subpass"
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055",
-          "text": " For any element of <code>pDependencies</code>, if the <code>dstSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, all stage flags included in the <code>dstStageMask</code> member of that dependency <strong class=\"purple\">must</strong> be a pipeline stage supported by the <a href=\"#synchronization-pipeline-stages-types\">pipeline</a> identified by the <code>pipelineBindPoint</code> member of the source subpass."
+          "text": " For any element of <code>pDependencies</code>, if the <code>dstSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, all stage flags included in the <code>dstStageMask</code> member of that dependency <strong class=\"purple\">must</strong> be a pipeline stage supported by the <a href=\"#synchronization-pipeline-stages-types\">pipeline</a> identified by the <code>pipelineBindPoint</code> member of the destination subpass"
         },
         {
           "vuid": "VUID-VkRenderPassCreateInfo2KHR-pCorrelatedViewMasks-03056",
@@ -3871,14 +3871,6 @@
     "VkSubpassDependency2KHR": {
       "(VK_KHR_create_renderpass2)": [
         {
-          "vuid": "VUID-VkSubpassDependency2KHR-srcSubpass-03078",
-          "text": " If <code>srcSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not include <code>VK_PIPELINE_STAGE_HOST_BIT</code>"
-        },
-        {
-          "vuid": "VUID-VkSubpassDependency2KHR-dstSubpass-03079",
-          "text": " If <code>dstSubpass</code> is not <code>VK_SUBPASS_EXTERNAL</code>, <code>dstStageMask</code> <strong class=\"purple\">must</strong> not include <code>VK_PIPELINE_STAGE_HOST_BIT</code>"
-        },
-        {
           "vuid": "VUID-VkSubpassDependency2KHR-srcStageMask-03080",
           "text": " If the <a href=\"#features-geometryShader\">geometry shaders</a> feature is not enabled, <code>srcStageMask</code> <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT</code>"
         },
@@ -3903,10 +3895,6 @@
           "text": " <code>srcSubpass</code> and <code>dstSubpass</code> <strong class=\"purple\">must</strong> not both be equal to <code>VK_SUBPASS_EXTERNAL</code>"
         },
         {
-          "vuid": "VUID-VkSubpassDependency2KHR-srcSubpass-02244",
-          "text": " If <code>srcSubpass</code> is equal to <code>dstSubpass</code>, <code>srcStageMask</code> and <code>dstStageMask</code> <strong class=\"purple\">must</strong> not set any bits that are neither <code>VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT</code>, nor one of the <a href=\"#synchronization-pipeline-stages-types\">graphics pipeline stages</a>"
-        },
-        {
           "vuid": "VUID-VkSubpassDependency2KHR-srcSubpass-03087",
           "text": " If <code>srcSubpass</code> is equal to <code>dstSubpass</code> and not all of the stages in <code>srcStageMask</code> and <code>dstStageMask</code> are <a href=\"#synchronization-framebuffer-regions\">framebuffer-space stages</a>, the <a href=\"#synchronization-pipeline-stages-order\">logically latest</a> pipeline stage in <code>srcStageMask</code> <strong class=\"purple\">must</strong> be <a href=\"#synchronization-pipeline-stages-order\">logically earlier</a> than or equal to the <a href=\"#synchronization-pipeline-stages-order\">logically earliest</a> pipeline stage in <code>dstStageMask</code>"
         },
@@ -4029,6 +4017,10 @@
     "vkCreateFramebuffer": {
       "core": [
         {
+          "vuid": "VUID-vkCreateFramebuffer-pCreateInfo-02777",
+          "text": " If <code>pCreateInfo</code>&#8594;<code>flags</code> does not include <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, and <code>attachmentCount</code> is not <code>0</code>, each element of <code>pCreateInfo</code>&#8594;<code>pAttachments</code> <strong class=\"purple\">must</strong> have been created on <code>device</code>"
+        },
+        {
           "vuid": "VUID-vkCreateFramebuffer-device-parameter",
           "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
         },
@@ -4053,6 +4045,10 @@
           "text": " <code>attachmentCount</code> <strong class=\"purple\">must</strong> be equal to the attachment count specified in <code>renderPass</code>"
         },
         {
+          "vuid": "VUID-VkFramebufferCreateInfo-flags-02778",
+          "text": " If <code>flags</code> does not include <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</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"
+        },
+        {
           "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00877",
           "text": " If <code>flags</code> does not include <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of <code>pAttachments</code> that is used as a color attachment or resolve attachment by <code>renderPass</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value including <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>"
         },
@@ -4125,10 +4121,6 @@
           "text": " <code>renderPass</code> <strong class=\"purple\">must</strong> be a valid <code>VkRenderPass</code> handle"
         },
         {
-          "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-parameter",
-          "text": " If <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 <code>VkImageView</code> handles"
-        },
-        {
           "vuid": "VUID-VkFramebufferCreateInfo-commonparent",
           "text": " Both of <code>renderPass</code>, and the elements of <code>pAttachments</code> that are valid handles <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
         }
@@ -4202,7 +4194,7 @@
       "(VK_VERSION_1_1,VK_KHR_maintenance1)": [
         {
           "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00891",
-          "text": " Each element of <code>pAttachments</code> that is a 2D or 2D array image view taken from a 3D image <strong class=\"purple\">must</strong> not be a depth/stencil format"
+          "text": " If <code>flags</code> does not include <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of <code>pAttachments</code> that is a 2D or 2D array image view taken from a 3D image <strong class=\"purple\">must</strong> not be a depth/stencil format"
         }
       ],
       "(VK_KHR_imageless_framebuffer)": [
@@ -4433,6 +4425,10 @@
     "vkCmdBeginRenderPass2KHR": {
       "(VK_KHR_create_renderpass2)": [
         {
+          "vuid": "VUID-vkCmdBeginRenderPass2KHR-framebuffer-02779",
+          "text": " Both the <code>framebuffer</code> and <code>renderPass</code> members of <code>pRenderPassBegin</code> <strong class=\"purple\">must</strong> have been created on the same <a href=\"#VkDevice\">VkDevice</a> that <code>commandBuffer</code> was allocated on"
+        },
+        {
           "vuid": "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03094",
           "text": " If any of the <code>initialLayout</code> or <code>finalLayout</code> member of the <code>VkAttachmentDescription</code> structures or the <code>layout</code> member of the <code>VkAttachmentReference</code> structures specified when creating the render pass specified in the <code>renderPass</code> member of <code>pRenderPassBegin</code> is <code>VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL</code> then the corresponding attachment image view of the framebuffer specified in the <code>framebuffer</code> member of <code>pRenderPassBegin</code> <strong class=\"purple\">must</strong> have been created with a <code>usage</code> value including <code>VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT</code>"
         },
@@ -4535,10 +4531,6 @@
       ],
       "(VK_KHR_imageless_framebuffer)": [
         {
-          "vuid": "VUID-VkRenderPassBeginInfo-pNext-03206",
-          "text": " If the <a href=\"#features-imagelessFramebuffer\">imageless framebuffer</a> feature is not enabled, and the <code>pNext</code> chain includes an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a>, its <code>attachmentCount</code> <strong class=\"purple\">must</strong> be zero"
-        },
-        {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03207",
           "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that did not include <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, and the <code>pNext</code> chain includes an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a>, its <code>attachmentCount</code> <strong class=\"purple\">must</strong> be zero"
         },
@@ -4547,40 +4539,44 @@
           "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, the <code>attachmentCount</code> of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be equal to the value of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>attachmentImageInfoCount</code> used to create <code>framebuffer</code>"
         },
         {
+          "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-02780",
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> have been created on the same <a href=\"#VkDevice\">VkDevice</a> as <code>framebuffer</code> and <code>renderPass</code>"
+        },
+        {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03209",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> equal to the <code>flags</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>flags</code> equal to the <code>flags</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03210",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>usage</code> equal to the <code>usage</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>usage</code> equal to the <code>usage</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03211",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> with a width equal to the <code>width</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> with a width equal to the <code>width</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03212",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> with a height equal to the <code>height</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> with a height equal to the <code>height</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03213",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageViewCreateInfo\">VkImageViewCreateInfo</a>::<code>subresourceRange.pname</code>:layerCount equal to the <code>layerCount</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageViewCreateInfo\">VkImageViewCreateInfo</a>::<code>subresourceRange.pname</code>:layerCount equal to the <code>layerCount</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03214",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageFormatListCreateInfoKHR\">VkImageFormatListCreateInfoKHR</a>::<code>viewFormatCount</code> equal to the <code>viewFormatCount</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageFormatListCreateInfoKHR\">VkImageFormatListCreateInfoKHR</a>::<code>viewFormatCount</code> equal to the <code>viewFormatCount</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03215",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a set of elements in <a href=\"#VkImageFormatListCreateInfoKHR\">VkImageFormatListCreateInfoKHR</a>::<code>pViewFormats</code> equal to the set of elements in the <code>pViewFormats</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a set of elements in <a href=\"#VkImageFormatListCreateInfoKHR\">VkImageFormatListCreateInfoKHR</a>::<code>pViewFormats</code> equal to the set of elements in the <code>pViewFormats</code> member of the corresponding element of <a href=\"#VkFramebufferAttachmentsCreateInfoKHR\">VkFramebufferAttachmentsCreateInfoKHR</a>::<code>pAttachments</code> used to create <code>framebuffer</code>"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03216",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageViewCreateInfo\">VkImageViewCreateInfo</a>::<code>format</code> equal to the corresponding value of <a href=\"#VkAttachmentDescription\">VkAttachmentDescription</a>::<code>format</code> in <code>renderPass</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageViewCreateInfo\">VkImageViewCreateInfo</a>::<code>format</code> equal to the corresponding value of <a href=\"#VkAttachmentDescription\">VkAttachmentDescription</a>::<code>format</code> in <code>renderPass</code>"
         },
         {
           "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03217",
-          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>attachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>samples</code> equal to the corresponding value of <a href=\"#VkAttachmentDescription\">VkAttachmentDescription</a>::<code>samples</code> in <code>renderPass</code>"
+          "text": " If <code>framebuffer</code> was created with a <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>flags</code> value that included <code>VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR</code>, each element of the <code>pAttachments</code> member of an instance of <a href=\"#VkRenderPassAttachmentBeginInfoKHR\">VkRenderPassAttachmentBeginInfoKHR</a> included in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be a <a href=\"#VkImageView\">VkImageView</a> of an image created with a value of <a href=\"#VkImageCreateInfo\">VkImageCreateInfo</a>::<code>samples</code> equal to the corresponding value of <a href=\"#VkAttachmentDescription\">VkAttachmentDescription</a>::<code>samples</code> in <code>renderPass</code>"
         }
       ]
     },
@@ -4919,8 +4915,8 @@
           "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkShaderModuleValidationCacheCreateInfoEXT\">VkShaderModuleValidationCacheCreateInfoEXT</a>"
         },
         {
-          "vuid": "VUID-VkShaderModuleCreateInfo-flags-zerobitmask",
-          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+          "vuid": "VUID-VkShaderModuleCreateInfo-flags-parameter",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkShaderModuleCreateFlagBits\">VkShaderModuleCreateFlagBits</a> values"
         },
         {
           "vuid": "VUID-VkShaderModuleCreateInfo-pCode-parameter",
@@ -5260,7 +5256,11 @@
         },
         {
           "vuid": "VUID-VkComputePipelineCreateInfo-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineCreationFeedbackCreateInfoEXT\">VkPipelineCreationFeedbackCreateInfoEXT</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=\"#VkPipelineCompilerControlCreateInfoAMD\">VkPipelineCompilerControlCreateInfoAMD</a> or <a href=\"#VkPipelineCreationFeedbackCreateInfoEXT\">VkPipelineCreationFeedbackCreateInfoEXT</a>"
+        },
+        {
+          "vuid": "VUID-VkComputePipelineCreateInfo-sType-unique",
+          "text": " Each <code>sType</code> member in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be unique"
         },
         {
           "vuid": "VUID-VkComputePipelineCreateInfo-flags-parameter",
@@ -5352,11 +5352,11 @@
         },
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>"
         },
         {
-          "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask",
-          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-parameter",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkPipelineShaderStageCreateFlagBits\">VkPipelineShaderStageCreateFlagBits</a> values"
         },
         {
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-parameter",
@@ -5398,6 +5398,60 @@
           "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-01511",
           "text": " If <code>stage</code> is <code>VK_SHADER_STAGE_FRAGMENT_BIT</code>, and the identified entry point writes to <code>FragStencilRefEXT</code> in any execution path, it <strong class=\"purple\">must</strong> write to <code>FragStencilRefEXT</code> in all execution paths"
         }
+      ],
+      "(VK_EXT_subgroup_size_control)": [
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02784",
+          "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set, the <a href=\"#features-subgroupSizeControl\"><code>subgroupSizeControl</code></a> feature <strong class=\"purple\">must</strong> be enabled."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02785",
+          "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set, the <a href=\"#features-computeFullSubgroups\"><code>computeFullSubgroups</code></a> feature <strong class=\"purple\">must</strong> be enabled."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02754",
+          "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is chained to <code>pNext</code>, <code>flags</code> <strong class=\"purple\">must</strong> not have the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02755",
+          "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is chained to <code>pNext</code>, the <a href=\"#features-subgroupSizeControl\"><code>subgroupSizeControl</code></a> feature <strong class=\"purple\">must</strong> be enabled, and <code>stage</code> <strong class=\"purple\">must</strong> be a valid bit specified in <a href=\"#limits-required-subgroup-size-stages\"><code>requiredSubgroupSizeStages</code></a>."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02756",
+          "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is chained to <code>pNext</code> and <code>stage</code> is VK_SHADER_STAGE_COMPUTE_BIT then local workgroup size of the shader <strong class=\"purple\">must</strong> be less than or equal to the product of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>::<code>requiredSubgroupSize</code> and <a href=\"#limits-max-subgroups-per-workgroup\"><code>maxComputeWorkgroupSubgroups</code></a>."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02757",
+          "text": " If a <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is chained to <code>pNext</code>, and <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a>::<code>requiredSubgroupSize</code>."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02758",
+          "text": " If <code>flags</code> has both the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> and <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flags set, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#limits-max-subgroup-size\"><code>maxSubgroupSize</code></a>."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02759",
+          "text": " If <code>flags</code> has the <code>VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT</code> flag set and <code>flags</code> does not have the <code>VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT</code> flag set and no <a href=\"#VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT\">VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT</a> structure is chained to <code>pNext</code>, the local workgroup size in the X dimension of the pipeline <strong class=\"purple\">must</strong> be a multiple of <a href=\"#limits-subgroup-size\"><code>subgroupSize</code></a>."
+        }
+      ]
+    },
+    "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT": {
+      "(VK_EXT_subgroup_size_control)": [
+        {
+          "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02760",
+          "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be a power-of-two integer."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02761",
+          "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be greater or equal to <a href=\"#limits-min-subgroup-size\">minSubgroupSize</a>."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02762",
+          "text": " <code>requiredSubgroupSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-max-subgroup-size\">maxSubgroupSize</a>."
+        },
+        {
+          "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT</code>"
+        }
       ]
     },
     "vkCreateGraphicsPipelines": {
@@ -5596,7 +5650,7 @@
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineCreationFeedbackCreateInfoEXT\">VkPipelineCreationFeedbackCreateInfoEXT</a>, <a href=\"#VkPipelineDiscardRectangleStateCreateInfoEXT\">VkPipelineDiscardRectangleStateCreateInfoEXT</a>, or <a href=\"#VkPipelineRepresentativeFragmentTestStateCreateInfoNV\">VkPipelineRepresentativeFragmentTestStateCreateInfoNV</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=\"#VkPipelineCompilerControlCreateInfoAMD\">VkPipelineCompilerControlCreateInfoAMD</a>, <a href=\"#VkPipelineCreationFeedbackCreateInfoEXT\">VkPipelineCreationFeedbackCreateInfoEXT</a>, <a href=\"#VkPipelineDiscardRectangleStateCreateInfoEXT\">VkPipelineDiscardRectangleStateCreateInfoEXT</a>, or <a href=\"#VkPipelineRepresentativeFragmentTestStateCreateInfoNV\">VkPipelineRepresentativeFragmentTestStateCreateInfoNV</a>"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-sType-unique",
@@ -5784,6 +5838,16 @@
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-None-02322",
           "text": " If there are any mesh shader stages in the pipeline there <strong class=\"purple\">must</strong> not be any shader stage in the pipeline with a <code>Xfb</code> execution mode."
         }
+      ],
+      "(VK_EXT_line_rasterization)": [
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
+          "text": " If the <code>lineRasterizationMode</code> member of a <a href=\"#VkPipelineRasterizationLineStateCreateInfoEXT\">VkPipelineRasterizationLineStateCreateInfoEXT</a> structure chained to the <code>pNext</code> chain of <code>pRasterizationState</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code> or <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code> and if rasterization is enabled, then the <code>alphaToCoverageEnable</code>, <code>alphaToOneEnable</code>, and <code>sampleShadingEnable</code> members of <code>pMultisampleState</code> <strong class=\"purple\">must</strong> all be <code>VK_FALSE</code>"
+        },
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767",
+          "text": " If the <code>stippledLineEnable</code> member of <a href=\"#VkPipelineRasterizationLineStateCreateInfoEXT\">VkPipelineRasterizationLineStateCreateInfoEXT</a> is <code>VK_TRUE</code> and no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> is <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code>, then the <code>lineStippleFactor</code> member of <a href=\"#VkPipelineRasterizationLineStateCreateInfoEXT\">VkPipelineRasterizationLineStateCreateInfoEXT</a> <strong class=\"purple\">must</strong> be in the range <span class=\"eq\">[1,256]</span>"
+        }
       ]
     },
     "VkPipelineDynamicStateCreateInfo": {
@@ -6072,6 +6136,182 @@
         }
       ]
     },
+    "vkGetPipelineExecutablePropertiesKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pipelineExecutableProperties-03270",
+          "text": " <a href=\"#features-pipelineExecutableProperties\"><code>pipelineExecutableProperties</code></a> <strong class=\"purple\">must</strong> be enabled."
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pipeline-03271",
+          "text": " <code>pipeline</code> member of <code>pPipelineInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>."
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pPipelineInfo-parameter",
+          "text": " <code>pPipelineInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineInfoKHR</code> structure"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pExecutableCount-parameter",
+          "text": " <code>pExecutableCount</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>uint32_t</code> value"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pProperties-parameter",
+          "text": " If the value referenced by <code>pExecutableCount</code> is not <code>0</code>, and <code>pProperties</code> is not <code>NULL</code>, <code>pProperties</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pExecutableCount</code> <code>VkPipelineExecutablePropertiesKHR</code> structures"
+        }
+      ]
+    },
+    "VkPipelineInfoKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-VkPipelineInfoKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineInfoKHR-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineInfoKHR-pipeline-parameter",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a valid <code>VkPipeline</code> handle"
+        }
+      ]
+    },
+    "VkPipelineExecutablePropertiesKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-VkPipelineExecutablePropertiesKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutablePropertiesKHR-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        }
+      ]
+    },
+    "vkGetPipelineExecutableStatisticsKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipelineExecutableInfo-03272",
+          "text": " <a href=\"#features-pipelineExecutableInfo\"><code>pipelineExecutableInfo</code></a> <strong class=\"purple\">must</strong> be enabled."
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03273",
+          "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>."
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03274",
+          "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR</code> set in the <code>flags</code> field of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a> or <a href=\"#VkComputePipelineCreateInfo\">VkComputePipelineCreateInfo</a>."
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pExecutableInfo-parameter",
+          "text": " <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineExecutableInfoKHR</code> structure"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pStatisticCount-parameter",
+          "text": " <code>pStatisticCount</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>uint32_t</code> value"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pStatistics-parameter",
+          "text": " If the value referenced by <code>pStatisticCount</code> is not <code>0</code>, and <code>pStatistics</code> is not <code>NULL</code>, <code>pStatistics</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pStatisticCount</code> <code>VkPipelineExecutableStatisticKHR</code> structures"
+        }
+      ]
+    },
+    "VkPipelineExecutableInfoKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-VkPipelineExecutableInfoKHR-executableIndex-03275",
+          "text": " <code>executableIndex</code> <strong class=\"purple\">must</strong> be less than the number of executables associated with <code>pipeline</code> as returned in the <code>pExecutableCount</code> parameter of <code>vkGetPipelineExecutablePropertiesKHR</code>."
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutableInfoKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutableInfoKHR-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutableInfoKHR-pipeline-parameter",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a valid <code>VkPipeline</code> handle"
+        }
+      ]
+    },
+    "VkPipelineExecutableStatisticKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-VkPipelineExecutableStatisticKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutableStatisticKHR-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        }
+      ]
+    },
+    "vkGetPipelineExecutableInternalRepresentationsKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipelineExecutableProperties-03276",
+          "text": " <a href=\"#features-pipelineExecutableProperties\"><code>pipelineExecutableProperties</code></a> <strong class=\"purple\">must</strong> be enabled."
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03277",
+          "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>device</code>."
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03278",
+          "text": " <code>pipeline</code> member of <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR</code> set in the <code>flags</code> field of <a href=\"#VkGraphicsPipelineCreateInfo\">VkGraphicsPipelineCreateInfo</a> or <a href=\"#VkComputePipelineCreateInfo\">VkComputePipelineCreateInfo</a>."
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pExecutableInfo-parameter",
+          "text": " <code>pExecutableInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkPipelineExecutableInfoKHR</code> structure"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentationCount-parameter",
+          "text": " <code>pInternalRepresentationCount</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>uint32_t</code> value"
+        },
+        {
+          "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentations-parameter",
+          "text": " If the value referenced by <code>pInternalRepresentationCount</code> is not <code>0</code>, and <code>pInternalRepresentations</code> is not <code>NULL</code>, <code>pInternalRepresentations</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pInternalRepresentationCount</code> <code>VkPipelineExecutableInternalRepresentationKHR</code> structures"
+        }
+      ]
+    },
+    "VkPipelineExecutableInternalRepresentationKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-VkPipelineExecutableInternalRepresentationKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutableInternalRepresentationKHR-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutableInternalRepresentationKHR-name-parameter",
+          "text": " <code>name</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_DESCRIPTION_SIZE"
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutableInternalRepresentationKHR-description-parameter",
+          "text": " <code>description</code> <strong class=\"purple\">must</strong> be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_DESCRIPTION_SIZE"
+        },
+        {
+          "vuid": "VUID-VkPipelineExecutableInternalRepresentationKHR-pData-parameter",
+          "text": " If <code>dataSize</code> is not <code>0</code>, and <code>pData</code> is not <code>NULL</code>, <code>pData</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>dataSize</code> bytes"
+        }
+      ]
+    },
     "vkGetShaderInfoAMD": {
       "(VK_AMD_shader_info)": [
         {
@@ -6104,6 +6344,18 @@
         }
       ]
     },
+    "VkPipelineCompilerControlCreateInfoAMD": {
+      "(VK_AMD_pipeline_compiler_control)": [
+        {
+          "vuid": "VUID-VkPipelineCompilerControlCreateInfoAMD-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineCompilerControlCreateInfoAMD-compilerControlFlags-zerobitmask",
+          "text": " <code>compilerControlFlags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+        }
+      ]
+    },
     "vkCreateRayTracingPipelinesNV": {
       "(VK_NV_ray_tracing)": [
         {
@@ -6402,11 +6654,7 @@
         },
         {
           "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-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=\"#VkPhysicalDeviceMemoryBudgetPropertiesEXT\">VkPhysicalDeviceMemoryBudgetPropertiesEXT</a> or <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>"
-        },
-        {
-          "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-sType-unique",
-          "text": " Each <code>sType</code> member in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be unique"
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPhysicalDeviceMemoryBudgetPropertiesEXT\">VkPhysicalDeviceMemoryBudgetPropertiesEXT</a>"
         }
       ]
     },
@@ -6444,6 +6692,12 @@
           "vuid": "VUID-vkAllocateMemory-pMemory-parameter",
           "text": " <code>pMemory</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>VkDeviceMemory</code> handle"
         }
+      ],
+      "(VK_AMD_device_coherent_memory)": [
+        {
+          "vuid": "VUID-vkAllocateMemory-deviceCoherentMemory-02790",
+          "text": " If the <a href=\"#features-deviceCoherentMemory\"><code>deviceCoherentMemory</code></a> feature is not enabled, <code>pAllocateInfo</code>-&gt;<code>memoryTypeIndex</code> <strong class=\"purple\">must</strong> not identify a memory type supporting <code>VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD</code>"
+        }
       ]
     },
     "VkMemoryAllocateInfo": {
@@ -6994,7 +7248,7 @@
       "(VK_EXT_external_memory_host)": [
         {
           "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747",
-          "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be supported for import, as reported in <a href=\"#VkExternalMemoryPropertiesKHR\">VkExternalMemoryPropertiesKHR</a>"
+          "text": " If <code>handleType</code> is not <code>0</code>, it <strong class=\"purple\">must</strong> be supported for import, as reported in <a href=\"#VkExternalMemoryProperties\">VkExternalMemoryProperties</a>"
         },
         {
           "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748",
@@ -7106,7 +7360,7 @@
       "(VK_ANDROID_external_memory_android_hardware_buffer)": [
         {
           "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882",
-          "text": " <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportMemoryAllocateInfoKHR\">VkExportMemoryAllocateInfoKHR</a>::<code>handleTypes</code> when <code>memory</code> was created."
+          "text": " <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID</code> <strong class=\"purple\">must</strong> have been included in <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> when <code>memory</code> was created."
         },
         {
           "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883",
@@ -7700,7 +7954,7 @@
         },
         {
           "vuid": "VUID-VkBufferViewCreateInfo-offset-02749",
-          "text": " If the <a href=\"#features-features-texelBufferAlignment\">texelBufferAlignment</a> feature is not enabled, <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of <code>VkPhysicalDeviceLimits</code>::<code>minTexelBufferOffsetAlignment</code>"
+          "text": " If the <a href=\"#features-texelBufferAlignment\">texelBufferAlignment</a> feature is not enabled, <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of <code>VkPhysicalDeviceLimits</code>::<code>minTexelBufferOffsetAlignment</code>"
         },
         {
           "vuid": "VUID-VkBufferViewCreateInfo-range-00928",
@@ -7758,11 +8012,11 @@
       "(VK_EXT_texel_buffer_alignment)": [
         {
           "vuid": "VUID-VkBufferViewCreateInfo-buffer-02750",
-          "text": " If the <a href=\"#features-features-texelBufferAlignment\">texelBufferAlignment</a> feature is enabled and if <code>buffer</code> was created with <code>usage</code> containing <code>VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT</code>, <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of the lesser of <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>::<code>storageTexelBufferOffsetAlignmentBytes</code> or, if <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>::<code>storageTexelBufferOffsetSingleTexelAlignment</code> is <code>VK_TRUE</code>, the size of a texel of the requested <code>format</code>. If the size of a texel is a multiple of three bytes, then the size of a single component of <code>format</code> is used instead"
+          "text": " If the <a href=\"#features-texelBufferAlignment\">texelBufferAlignment</a> feature is enabled and if <code>buffer</code> was created with <code>usage</code> containing <code>VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT</code>, <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of the lesser of <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>::<code>storageTexelBufferOffsetAlignmentBytes</code> or, if <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>::<code>storageTexelBufferOffsetSingleTexelAlignment</code> is <code>VK_TRUE</code>, the size of a texel of the requested <code>format</code>. If the size of a texel is a multiple of three bytes, then the size of a single component of <code>format</code> is used instead"
         },
         {
           "vuid": "VUID-VkBufferViewCreateInfo-buffer-02751",
-          "text": " If the <a href=\"#features-features-texelBufferAlignment\">texelBufferAlignment</a> feature is enabled and if <code>buffer</code> was created with <code>usage</code> containing <code>VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT</code>, <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of the lesser of <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>::<code>uniformTexelBufferOffsetAlignmentBytes</code> or, if <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>::<code>uniformTexelBufferOffsetSingleTexelAlignment</code> is <code>VK_TRUE</code>, the size of a texel of the requested <code>format</code>. If the size of a texel is a multiple of three bytes, then the size of a single component of <code>format</code> is used instead"
+          "text": " If the <a href=\"#features-texelBufferAlignment\">texelBufferAlignment</a> feature is enabled and if <code>buffer</code> was created with <code>usage</code> containing <code>VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT</code>, <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of the lesser of <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>::<code>uniformTexelBufferOffsetAlignmentBytes</code> or, if <a href=\"#VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT\">VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT</a>::<code>uniformTexelBufferOffsetSingleTexelAlignment</code> is <code>VK_TRUE</code>, the size of a texel of the requested <code>format</code>. If the size of a texel is a multiple of three bytes, then the size of a single component of <code>format</code> is used instead"
         }
       ]
     },
@@ -8412,7 +8666,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=\"#VkPhysicalDeviceImageFormatInfo2KHR\">VkPhysicalDeviceImageFormatInfo2KHR</a> extended with <a href=\"#VkPhysicalDeviceImageDrmFormatModifierInfoEXT\">VkPhysicalDeviceImageDrmFormatModifierInfoEXT</a>."
+          "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>."
         },
         {
           "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265",
@@ -9020,7 +9274,7 @@
         },
         {
           "vuid": "VUID-VkImageViewHandleInfoNVX-imageView-02656",
-          "text": "    If descriptorType is <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code> or    <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, the image that    <code>imageView</code> was created from <strong class=\"purple\">must</strong> have been created with the    <code>VK_IMAGE_USAGE_SAMPLED_BIT</code> usage bit set"
+          "text": " If descriptorType is <code>VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE</code> or <code>VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER</code>, the image that <code>imageView</code> was created from <strong class=\"purple\">must</strong> have been created with the <code>VK_IMAGE_USAGE_SAMPLED_BIT</code> usage bit set"
         },
         {
           "vuid": "VUID-VkImageViewHandleInfoNVX-imageView-02657",
@@ -9318,11 +9572,11 @@
       "(VK_VERSION_1_1,VK_KHR_external_memory)": [
         {
           "vuid": "VUID-vkBindBufferMemory-memory-02726",
-          "text": " If <code>memory</code> was allocated with <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> not equal to <code>0</code>, at least one handle type it contained must also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created."
+          "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"
         },
         {
           "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 must also have been set in <a href=\"#VkExternalMemoryBufferCreateInfo\">VkExternalMemoryBufferCreateInfo</a>::<code>handleTypes</code> when <code>buffer</code> was created."
+          "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"
         }
       ]
     },
@@ -9416,6 +9670,16 @@
           "vuid": "VUID-VkBindBufferMemoryInfo-pNext-01605",
           "text": " If the <code>pNext</code> chain includes <a href=\"#VkBindBufferMemoryDeviceGroupInfo\">VkBindBufferMemoryDeviceGroupInfo</a>, all instances of <code>memory</code> specified by <a href=\"#VkBindBufferMemoryDeviceGroupInfo\">VkBindBufferMemoryDeviceGroupInfo</a>::<code>pDeviceIndices</code> <strong class=\"purple\">must</strong> have been allocated"
         }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)": [
+        {
+          "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=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created"
+        },
+        {
+          "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"
+        }
       ]
     },
     "VkBindBufferMemoryDeviceGroupInfo": {
@@ -9500,7 +9764,7 @@
       "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VK_NV_dedicated_allocation_image_aliasing)": [
         {
           "vuid": "VUID-vkBindImageMemory-memory-01509",
-          "text": " If the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included an instance of <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>image</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero."
+          "text": " If the <code>VkMemoryAllocateInfo</code> provided when <code>memory</code> was allocated included an instance of <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a> in its <code>pNext</code> chain, and <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> was not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, then <code>image</code> <strong class=\"purple\">must</strong> equal <a href=\"#VkMemoryDedicatedAllocateInfo\">VkMemoryDedicatedAllocateInfo</a>::<code>image</code> and <code>memoryOffset</code> <strong class=\"purple\">must</strong> be zero"
         }
       ],
       "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_NV_dedicated_allocation_image_aliasing)": [
@@ -9538,11 +9802,11 @@
       "(VK_VERSION_1_1,VK_KHR_external_memory)": [
         {
           "vuid": "VUID-vkBindImageMemory-memory-02728",
-          "text": " If <code>memory</code> was allocated with <a href=\"#VkExportMemoryAllocateInfo\">VkExportMemoryAllocateInfo</a>::<code>handleTypes</code> not equal to <code>0</code>, at least one handle type it contained must also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created."
+          "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"
         },
         {
           "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 must also have been set in <a href=\"#VkExternalMemoryImageCreateInfo\">VkExternalMemoryImageCreateInfo</a>::<code>handleTypes</code> when <code>image</code> was created."
+          "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"
         }
       ]
     },
@@ -9702,7 +9966,7 @@
       "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [
         {
           "vuid": "VUID-VkBindImageMemoryInfo-image-01630",
-          "text": " If <code>image</code> was created with a valid swapchain handle in <a href=\"#VkImageSwapchainCreateInfoKHR\">VkImageSwapchainCreateInfoKHR</a>::<code>swapchain</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a valid instance of <a href=\"#VkBindImageMemorySwapchainInfoKHR\">VkBindImageMemorySwapchainInfoKHR</a>"
+          "text": " If <code>image</code> was created with a valid swapchain handle in <a href=\"#VkImageSwapchainCreateInfoKHR\">VkImageSwapchainCreateInfoKHR</a>::<code>swapchain</code>, then the <code>pNext</code> chain <strong class=\"purple\">must</strong> include a valid instance of <a href=\"#VkBindImageMemorySwapchainInfoKHR\">VkBindImageMemorySwapchainInfoKHR</a> containing the same swapchain handle."
         },
         {
           "vuid": "VUID-VkBindImageMemoryInfo-pNext-01631",
@@ -9712,6 +9976,16 @@
           "vuid": "VUID-VkBindImageMemoryInfo-pNext-01632",
           "text": " If the <code>pNext</code> chain does not include an instance of <a href=\"#VkBindImageMemorySwapchainInfoKHR\">VkBindImageMemorySwapchainInfoKHR</a>, <code>memory</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDeviceMemory\">VkDeviceMemory</a> handle"
         }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)": [
+        {
+          "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"
+        },
+        {
+          "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"
+        }
       ]
     },
     "VkBindImageMemoryDeviceGroupInfo": {
@@ -9871,10 +10145,22 @@
           "text": " If <code>type</code> is <code>VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV</code> then <code>instanceCount</code> <strong class=\"purple\">must</strong> be <code>0</code>"
         },
         {
+          "vuid": "VUID-VkAccelerationStructureInfoNV-type-02786",
+          "text": " If <code>type</code> is <code>VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV</code> then the <code>geometryType</code> member of each geometry in <code>pGeometries</code> <strong class=\"purple\">must</strong> be the same"
+        },
+        {
           "vuid": "VUID-VkAccelerationStructureInfoNV-flags-02592",
           "text": " If <code>flags</code> has the <code>VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV</code> bit set, then it <strong class=\"purple\">must</strong> not have the <code>VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV</code> bit set"
         },
         {
+          "vuid": "VUID-VkAccelerationStructureInfoNV-scratch-02781",
+          "text": " <code>scratch</code> <strong class=\"purple\">must</strong> have been created with <code>VK_BUFFER_USAGE_RAY_TRACING_BIT_NV</code> usage flag"
+        },
+        {
+          "vuid": "VUID-VkAccelerationStructureInfoNV-instanceData-02782",
+          "text": " If <code>instanceData</code> is not <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, <code>instanceData</code> <strong class=\"purple\">must</strong> have been created with <code>VK_BUFFER_USAGE_RAY_TRACING_BIT_NV</code> usage flag"
+        },
+        {
           "vuid": "VUID-VkAccelerationStructureInfoNV-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV</code>"
         },
@@ -10179,6 +10465,10 @@
           "text": " <code>dataSize</code> <strong class=\"purple\">must</strong> be large enough to contain the result of the query, as described above"
         },
         {
+          "vuid": "VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-02787",
+          "text": " <code>accelerationStructure</code> <strong class=\"purple\">must</strong> be bound completely and contiguously to a single <code>VkDeviceMemory</code> object via <a href=\"#vkBindAccelerationStructureMemoryNV\">vkBindAccelerationStructureMemoryNV</a>"
+        },
+        {
           "vuid": "VUID-vkGetAccelerationStructureHandleNV-device-parameter",
           "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
         },
@@ -11271,6 +11561,10 @@
         {
           "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 <code>VkDescriptorSet</code> 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>"
         }
       ]
     },
@@ -11559,6 +11853,10 @@
           "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_STORAGE_IMAGE</code>, the <code>imageView</code> member of each element of <code>pImageInfo</code> <strong class=\"purple\">must</strong> have been created with <code>VK_IMAGE_USAGE_STORAGE_BIT</code> set"
         },
         {
+          "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02752",
+          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_SAMPLER</code>, then <code>dstSet</code> <strong class=\"purple\">must</strong> not have been allocated with a layout that included immutable samplers for <code>dstBinding</code>"
+        },
+        {
           "vuid": "VUID-VkWriteDescriptorSet-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET</code>"
         },
@@ -11685,6 +11983,10 @@
           "text": " <code>accelerationStructureCount</code> <strong class=\"purple\">must</strong> be equal to <code>descriptorCount</code> in the extended structure"
         },
         {
+          "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-02764",
+          "text": " Each acceleration structure in <code>pAccelerationStructures</code> must have been created with <code>VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV</code>"
+        },
+        {
           "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV</code>"
         },
@@ -11725,6 +12027,10 @@
           "text": " If <code>srcSet</code> is equal to <code>dstSet</code>, then the source and destination ranges of descriptors <strong class=\"purple\">must</strong> not overlap, where the ranges <strong class=\"purple\">may</strong> include array elements from consecutive bindings as described by <a href=\"#descriptorsets-updates-consecutive\">consecutive binding updates</a>"
         },
         {
+          "vuid": "VUID-VkCopyDescriptorSet-dstBinding-02753",
+          "text": " If the descriptor type of the descriptor set binding specified by <code>dstBinding</code> is <code>VK_DESCRIPTOR_TYPE_SAMPLER</code>, then <code>dstSet</code> <strong class=\"purple\">must</strong> not have been allocated with a layout that included immutable samplers for <code>dstBinding</code>"
+        },
+        {
           "vuid": "VUID-VkCopyDescriptorSet-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET</code>"
         },
@@ -12221,6 +12527,10 @@
           "text": " If <code>queryType</code> is <code>VK_QUERY_TYPE_PIPELINE_STATISTICS</code>, <code>pipelineStatistics</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkQueryPipelineStatisticFlagBits\">VkQueryPipelineStatisticFlagBits</a> values"
         },
         {
+          "vuid": "VUID-VkQueryPoolCreateInfo-queryCount-02763",
+          "text": " <code>queryCount</code> <strong class=\"purple\">must</strong> be greater than 0"
+        },
+        {
           "vuid": "VUID-VkQueryPoolCreateInfo-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO</code>"
         },
@@ -15080,6 +15390,12 @@
           "vuid": "VUID-vkCmdBindIndexBuffer-indexType-02507",
           "text": " <code>indexType</code> <strong class=\"purple\">must</strong> not be <code>VK_INDEX_TYPE_NONE_NV</code>."
         }
+      ],
+      "(VK_EXT_index_type_uint8)": [
+        {
+          "vuid": "VUID-vkCmdBindIndexBuffer-indexType-02765",
+          "text": " If <code>indexType</code> is <code>VK_INDEX_TYPE_UINT8_EXT</code>, the <a href=\"#features-indexTypeUint8\">indexTypeUint8</a> feature <strong class=\"purple\">must</strong> be enabled"
+        }
       ]
     },
     "vkCmdDraw": {
@@ -17618,7 +17934,7 @@
         },
         {
           "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineRasterizationConservativeStateCreateInfoEXT\">VkPipelineRasterizationConservativeStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationDepthClipStateCreateInfoEXT\">VkPipelineRasterizationDepthClipStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationStateRasterizationOrderAMD\">VkPipelineRasterizationStateRasterizationOrderAMD</a>, or <a href=\"#VkPipelineRasterizationStateStreamCreateInfoEXT\">VkPipelineRasterizationStateStreamCreateInfoEXT</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkPipelineRasterizationConservativeStateCreateInfoEXT\">VkPipelineRasterizationConservativeStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationDepthClipStateCreateInfoEXT\">VkPipelineRasterizationDepthClipStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationLineStateCreateInfoEXT\">VkPipelineRasterizationLineStateCreateInfoEXT</a>, <a href=\"#VkPipelineRasterizationStateRasterizationOrderAMD\">VkPipelineRasterizationStateRasterizationOrderAMD</a>, or <a href=\"#VkPipelineRasterizationStateStreamCreateInfoEXT\">VkPipelineRasterizationStateStreamCreateInfoEXT</a>"
         },
         {
           "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-sType-unique",
@@ -18072,6 +18388,46 @@
         }
       ]
     },
+    "VkPipelineRasterizationLineStateCreateInfoEXT": {
+      "(VK_EXT_line_rasterization)": [
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768",
+          "text": " If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-rectangularLines\">rectangularLines</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769",
+          "text": " If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-bresenhamLines\">bresenhamLines</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770",
+          "text": " If <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-bresenhamLines\">smoothLines</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771",
+          "text": " If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT</code>, then the <a href=\"#features-stippledRectangularLines\">stippledRectangularLines</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772",
+          "text": " If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT</code>, then the <a href=\"#features-stippledBresenhamLines\">stippledBresenhamLines</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773",
+          "text": " If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT</code>, then the <a href=\"#features-stippledSmoothLines\">stippledSmoothLines</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774",
+          "text": " If <code>stippledLineEnable</code> is <code>VK_TRUE</code> and <code>lineRasterizationMode</code> is <code>VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT</code>, then the <a href=\"#features-stippledRectangularLines\">stippledRectangularLines</a> feature <strong class=\"purple\">must</strong> be enabled and <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>strictLines</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter",
+          "text": " <code>lineRasterizationMode</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLineRasterizationModeEXT\">VkLineRasterizationModeEXT</a> value"
+        }
+      ]
+    },
     "vkCmdSetLineWidth": {
       "core": [
         {
@@ -18096,6 +18452,30 @@
         }
       ]
     },
+    "vkCmdSetLineStippleEXT": {
+      "(VK_EXT_line_rasterization)": [
+        {
+          "vuid": "VUID-vkCmdSetLineStippleEXT-None-02775",
+          "text": " The bound graphics pipeline <strong class=\"purple\">must</strong> have been created with the <code>VK_DYNAMIC_STATE_LINE_STIPPLE_EXT</code> dynamic state enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776",
+          "text": " <code>lineStippleFactor</code> <strong class=\"purple\">must</strong> be in the range <span class=\"eq\">[1,256]</span>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        }
+      ]
+    },
     "vkCmdSetDepthBias": {
       "core": [
         {
@@ -19451,6 +19831,10 @@
           "text": " <code>type</code> <strong class=\"purple\">must</strong> be <code>VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX</code>"
         },
         {
+          "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-indexType-02783",
+          "text": " <code>indexType</code> <strong class=\"purple\">must</strong> be <code>VK_INDEX_TYPE_UINT16</code>, or <code>VK_INDEX_TYPE_UINT32</code>"
+        },
+        {
           "vuid": "VUID-VkObjectTableIndexBufferEntryNVX-type-parameter",
           "text": " <code>type</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkObjectEntryTypeNVX\">VkObjectEntryTypeNVX</a> value"
         },
@@ -20236,7 +20620,7 @@
         },
         {
           "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01116",
-          "text": " When a semaphore unsignal operation defined by any element of the <code>pWaitSemaphores</code> member of any element of <code>pBindInfo</code> executes on <code>queue</code>, no other queue <strong class=\"purple\">must</strong> be waiting on the same semaphore."
+          "text": " When a semaphore unsignal operation defined by any element of the <code>pWaitSemaphores</code> member of any element of <code>pBindInfo</code> executes on <code>queue</code>, there <strong class=\"purple\">must</strong> be no other queues waiting on the same semaphore."
         },
         {
           "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01117",
@@ -22328,7 +22712,7 @@
         },
         {
           "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01294",
-          "text": " When a semaphore unsignal operation defined by the elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> executes on <code>queue</code>, no other queue <strong class=\"purple\">must</strong> be waiting on the same semaphore."
+          "text": " When a semaphore unsignal operation defined by the elements of the <code>pWaitSemaphores</code> member of <code>pPresentInfo</code> executes on <code>queue</code>, there <strong class=\"purple\">must</strong> be no other queues waiting on the same semaphore."
         },
         {
           "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01295",
@@ -22721,6 +23105,10 @@
           "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support compute operations"
         },
         {
+          "vuid": "VUID-vkCmdTraceRaysNV-renderpass",
+          "text": " This command <strong class=\"purple\">must</strong> only be called outside of a render pass instance"
+        },
+        {
           "vuid": "VUID-vkCmdTraceRaysNV-commonparent",
           "text": " Each of <code>callableShaderBindingTableBuffer</code>, <code>commandBuffer</code>, <code>hitShaderBindingTableBuffer</code>, <code>missShaderBindingTableBuffer</code>, and <code>raygenShaderBindingTableBuffer</code> that are valid handles <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
         }
@@ -22827,6 +23215,10 @@
           "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support compute operations"
         },
         {
+          "vuid": "VUID-vkCmdBuildAccelerationStructureNV-renderpass",
+          "text": " This command <strong class=\"purple\">must</strong> only be called outside of a render pass instance"
+        },
+        {
           "vuid": "VUID-vkCmdBuildAccelerationStructureNV-commonparent",
           "text": " Each of <code>commandBuffer</code>, <code>dst</code>, <code>instanceData</code>, <code>scratch</code>, and <code>src</code> that are valid handles <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
         }
@@ -22875,6 +23267,10 @@
           "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support compute operations"
         },
         {
+          "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-renderpass",
+          "text": " This command <strong class=\"purple\">must</strong> only be called outside of a render pass instance"
+        },
+        {
           "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-accelerationStructureCount-arraylength",
           "text": " <code>accelerationStructureCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
         },
@@ -22919,6 +23315,10 @@
           "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support compute operations"
         },
         {
+          "vuid": "VUID-vkCmdCopyAccelerationStructureNV-renderpass",
+          "text": " This command <strong class=\"purple\">must</strong> only be called outside of a render pass instance"
+        },
+        {
           "vuid": "VUID-vkCmdCopyAccelerationStructureNV-commonparent",
           "text": " Each of <code>commandBuffer</code>, <code>dst</code>, and <code>src</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
         }
@@ -23072,11 +23472,11 @@
         }
       ]
     },
-    "VkPhysicalDeviceFloat16Int8FeaturesKHR": {
+    "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR": {
       "(VK_KHR_shader_float16_int8)": [
         {
-          "vuid": "VUID-VkPhysicalDeviceFloat16Int8FeaturesKHR-sType-sType",
-          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR</code>"
+          "vuid": "VUID-VkPhysicalDeviceShaderFloat16Int8FeaturesKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR</code>"
         }
       ]
     },
@@ -23328,11 +23728,11 @@
         }
       ]
     },
-    "VkPhysicalDeviceShaderIntegerFunctions2INTEL": {
+    "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL": {
       "(VK_INTEL_shader_integer_functions2)": [
         {
-          "vuid": "VUID-VkPhysicalDeviceShaderIntegerFunctions2INTEL-sType-sType",
-          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL</code>"
+          "vuid": "VUID-VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL</code>"
         }
       ]
     },
@@ -23344,6 +23744,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceIndexTypeUint8FeaturesEXT": {
+      "(VK_EXT_index_type_uint8)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceIndexTypeUint8FeaturesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV": {
       "(VK_NV_shader_sm_builtins)": [
         {
@@ -23352,6 +23760,14 @@
         }
       ]
     },
+    "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR": {
+      "(VK_KHR_pipeline_executable_properties)": [
+        {
+          "vuid": "VUID-VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT": {
       "(VK_EXT_shader_demote_to_helper_invocation)": [
         {
@@ -23368,6 +23784,38 @@
         }
       ]
     },
+    "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT": {
+      "(VK_EXT_texture_compression_astc_hdr)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceLineRasterizationFeaturesEXT": {
+      "(VK_EXT_line_rasterization)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceLineRasterizationFeaturesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT": {
+      "(VK_EXT_subgroup_size_control)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceSubgroupSizeControlFeaturesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT</code>"
+        }
+      ]
+    },
+    "VkPhysicalDeviceCoherentMemoryFeaturesAMD": {
+      "(VK_AMD_device_coherent_memory)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceCoherentMemoryFeaturesAMD-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD</code>"
+        }
+      ]
+    },
     "VkPhysicalDevicePushDescriptorPropertiesKHR": {
       "(VK_KHR_push_descriptor)": [
         {
@@ -23440,6 +23888,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT": {
+      "(VK_VERSION_1_1)+(VK_EXT_subgroup_size_control)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceSubgroupSizeControlPropertiesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT": {
       "(VK_EXT_blend_operation_advanced)": [
         {
@@ -23528,6 +23984,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceShaderCoreProperties2AMD": {
+      "(VK_AMD_shader_core_properties2)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceShaderCoreProperties2AMD-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceDepthStencilResolvePropertiesKHR": {
       "(VK_KHR_depth_stencil_resolve)": [
         {
@@ -23584,6 +24048,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceLineRasterizationPropertiesEXT": {
+      "(VK_EXT_line_rasterization)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceLineRasterizationPropertiesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT</code>"
+        }
+      ]
+    },
     "vkGetPhysicalDeviceMultisamplePropertiesEXT": {
       "(VK_EXT_sample_locations)": [
         {
diff --git a/registry/vk.xml b/registry/vk.xml
index e3d040a..60d035a 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -154,7 +154,7 @@ server.
         <type category="define">// Vulkan 1.1 version number
 #define <name>VK_API_VERSION_1_1</name> <type>VK_MAKE_VERSION</type>(1, 1, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 114</type>
+#define <name>VK_HEADER_VERSION</name> 121</type>
 
         <type category="define">
 #define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type>
@@ -190,18 +190,20 @@ typedef void <name>CAMetalLayer</name>;
         <type requires="vk_platform" name="void"/>
         <type requires="vk_platform" name="char"/>
         <type requires="vk_platform" name="float"/>
+        <type requires="vk_platform" name="double"/>
         <type requires="vk_platform" name="uint8_t"/>
         <type requires="vk_platform" name="uint16_t"/>
         <type requires="vk_platform" name="uint32_t"/>
         <type requires="vk_platform" name="uint64_t"/>
         <type requires="vk_platform" name="int32_t"/>
+        <type requires="vk_platform" name="int64_t"/>
         <type requires="vk_platform" name="size_t"/>
         <type name="int"/>
 
             <comment>Bitmask types</comment>
         <type requires="VkFramebufferCreateFlagBits"      category="bitmask">typedef <type>VkFlags</type> <name>VkFramebufferCreateFlags</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkQueryPoolCreateFlags</name>;</type>
-        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkRenderPassCreateFlags</name>;</type>
+        <type requires="VkRenderPassCreateFlagBits"       category="bitmask">typedef <type>VkFlags</type> <name>VkRenderPassCreateFlags</name>;</type>
         <type requires="VkSamplerCreateFlagBits"          category="bitmask">typedef <type>VkFlags</type> <name>VkSamplerCreateFlags</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineLayoutCreateFlags</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCacheCreateFlags</name>;</type>
@@ -214,7 +216,7 @@ typedef void <name>CAMetalLayer</name>;
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineTessellationStateCreateFlags</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineInputAssemblyStateCreateFlags</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineVertexInputStateCreateFlags</name>;</type>
-        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineShaderStageCreateFlags</name>;</type>
+        <type requires="VkPipelineShaderStageCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineShaderStageCreateFlags</name>;</type>
         <type requires="VkDescriptorSetLayoutCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorSetLayoutCreateFlags</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkBufferViewCreateFlags</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkInstanceCreateFlags</name>;</type>
@@ -237,7 +239,7 @@ typedef void <name>CAMetalLayer</name>;
         <type requires="VkFormatFeatureFlagBits"          category="bitmask">typedef <type>VkFlags</type> <name>VkFormatFeatureFlags</name>;</type>
         <type requires="VkQueryControlFlagBits"           category="bitmask">typedef <type>VkFlags</type> <name>VkQueryControlFlags</name>;</type>
         <type requires="VkQueryResultFlagBits"            category="bitmask">typedef <type>VkFlags</type> <name>VkQueryResultFlags</name>;</type>
-        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkShaderModuleCreateFlags</name>;</type>
+        <type requires="VkShaderModuleCreateFlagBits"     category="bitmask">typedef <type>VkFlags</type> <name>VkShaderModuleCreateFlags</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkEventCreateFlags</name>;</type>
         <type requires="VkCommandPoolCreateFlagBits"          category="bitmask">typedef <type>VkFlags</type> <name>VkCommandPoolCreateFlags</name>;</type>
         <type requires="VkCommandPoolResetFlagBits"           category="bitmask">typedef <type>VkFlags</type> <name>VkCommandPoolResetFlags</name>;</type>
@@ -267,6 +269,8 @@ typedef void <name>CAMetalLayer</name>;
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorUpdateTemplateCreateFlags</name>;</type>
         <type                                             category="bitmask" name="VkDescriptorUpdateTemplateCreateFlagsKHR" alias="VkDescriptorUpdateTemplateCreateFlags"/>
         <type requires="VkPipelineCreationFeedbackFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCreationFeedbackFlagsEXT</name>;</type>
+        <type requires="VkPipelineCompilerControlFlagBitsAMD" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCompilerControlFlagsAMD</name>;</type>
+        <type requires="VkShaderCorePropertiesFlagBitsAMD" category="bitmask">typedef <type>VkFlags</type> <name>VkShaderCorePropertiesFlagsAMD</name>;</type>
 
             <comment>WSI extensions</comment>
         <type requires="VkCompositeAlphaFlagBitsKHR"      category="bitmask">typedef <type>VkFlags</type> <name>VkCompositeAlphaFlagsKHR</name>;</type>
@@ -331,6 +335,7 @@ typedef void <name>CAMetalLayer</name>;
         <type requires="VkResolveModeFlagBitsKHR"         category="bitmask">typedef <type>VkFlags</type> <name>VkResolveModeFlagsKHR</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineRasterizationStateStreamCreateFlagsEXT</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineRasterizationDepthClipStateCreateFlagsEXT</name>;</type>
+        <type requires="VkSwapchainImageUsageFlagBitsANDROID" category="bitmask">typedef <type>VkFlags</type> <name>VkSwapchainImageUsageFlagsANDROID</name>;</type>
 
 
             <comment>Types which can be void pointers or class pointers, selected at compile time</comment>
@@ -506,6 +511,10 @@ typedef void <name>CAMetalLayer</name>;
         <type name="VkPerformanceOverrideTypeINTEL" category="enum"/>
         <type name="VkPerformanceParameterTypeINTEL" category="enum"/>
         <type name="VkPerformanceValueTypeINTEL" category="enum"/>
+        <type name="VkLineRasterizationModeEXT" category="enum"/>
+        <type name="VkShaderModuleCreateFlagBits" category="enum"/>
+        <type name="VkPipelineCompilerControlFlagBitsAMD" category="enum"/>
+        <type name="VkShaderCorePropertiesFlagBitsAMD" category="enum"/>
 
             <comment>WSI extensions</comment>
         <type name="VkColorSpaceKHR" category="enum"/>
@@ -561,12 +570,15 @@ typedef void <name>CAMetalLayer</name>;
         <type name="VkDebugUtilsMessageSeverityFlagBitsEXT" category="enum"/>
         <type name="VkDebugUtilsMessageTypeFlagBitsEXT" category="enum"/>
         <type name="VkFullScreenExclusiveEXT" category="enum"/>
+        <type name="VkShaderFloatControlsIndependenceKHR" category="enum"/>
+        <type name="VkSwapchainImageUsageFlagBitsANDROID" category="enum"/>
 
             <comment>Enumerated types in the header, but not used by the API</comment>
         <type name="VkVendorId" category="enum"/>
         <type name="VkDriverIdKHR" category="enum"/>
         <type name="VkShadingRatePaletteEntryNV" category="enum"/>
         <type name="VkCoarseSampleOrderTypeNV" category="enum"/>
+        <type name="VkPipelineExecutableStatisticFormatKHR" category="enum"/>
 
         <comment>The PFN_vk*Function types are used by VkAllocationCallbacks below</comment>
         <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkInternalAllocationNotification</name>)(
@@ -1567,7 +1579,7 @@ typedef void <name>CAMetalLayer</name>;
             <member optional="true"><type>VkFramebufferCreateFlags</type>    <name>flags</name></member>
             <member><type>VkRenderPass</type>           <name>renderPass</name></member>
             <member optional="true"><type>uint32_t</type>               <name>attachmentCount</name></member>
-            <member len="attachmentCount">const <type>VkImageView</type>*     <name>pAttachments</name></member>
+            <member noautovalidity="true" len="attachmentCount">const <type>VkImageView</type>*     <name>pAttachments</name></member>
             <member><type>uint32_t</type>               <name>width</name></member>
             <member><type>uint32_t</type>               <name>height</name></member>
             <member><type>uint32_t</type>               <name>layers</name></member>
@@ -2989,17 +3001,18 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkBool32</type>                         <name>shaderDrawParameters</name></member>
         </type>
         <type category="struct" name="VkPhysicalDeviceShaderDrawParameterFeatures"             alias="VkPhysicalDeviceShaderDrawParametersFeatures"/>
-        <type category="struct" name="VkPhysicalDeviceFloat16Int8FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
-            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+        <type category="struct" name="VkPhysicalDeviceShaderFloat16Int8FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member noautovalidity="true"><type>void</type>*      <name>pNext</name></member>                            <!-- Pointer to next structure -->
             <member><type>VkBool32</type>                         <name>shaderFloat16</name></member>                 <!-- 16-bit floats (halfs) in shaders -->
             <member><type>VkBool32</type>                         <name>shaderInt8</name></member>                    <!-- 8-bit integers in shaders -->
         </type>
+        <type category="struct" name="VkPhysicalDeviceFloat16Int8FeaturesKHR" alias="VkPhysicalDeviceShaderFloat16Int8FeaturesKHR"/>
         <type category="struct" name="VkPhysicalDeviceFloatControlsPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member><type>void</type>*                            <name>pNext</name></member>
-            <member><type>VkBool32</type>                         <name>separateDenormSettings</name></member>
-            <member><type>VkBool32</type>                         <name>separateRoundingModeSettings</name></member>
+            <member><type>VkShaderFloatControlsIndependenceKHR</type> <name>denormBehaviorIndependence</name></member>
+            <member><type>VkShaderFloatControlsIndependenceKHR</type> <name>roundingModeIndependence</name></member>
             <member><type>VkBool32</type>                         <name>shaderSignedZeroInfNanPreserveFloat16</name></member>  <!-- An implementation can preserve signed zero, nan, inf -->
             <member><type>VkBool32</type>                         <name>shaderSignedZeroInfNanPreserveFloat32</name></member>  <!-- An implementation can preserve signed zero, nan, inf -->
             <member><type>VkBool32</type>                         <name>shaderSignedZeroInfNanPreserveFloat64</name></member>  <!-- An implementation can preserve signed zero, nan, inf -->
@@ -3021,6 +3034,10 @@ typedef void <name>CAMetalLayer</name>;
             <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
             <member><type>VkBool32</type>                           <name>hostQueryReset</name></member>
         </type>
+        <type category="struct" name="VkNativeBufferUsage2ANDROID">
+            <member><type>uint64_t</type> <name>consumer</name></member>
+            <member><type>uint64_t</type> <name>producer</name></member>
+        </type>
         <type category="struct" name="VkNativeBufferANDROID">
             <member values="VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>* <name>pNext</name></member>
@@ -3028,6 +3045,17 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>int</type> <name>stride</name></member>
             <member><type>int</type> <name>format</name></member>
             <member><type>int</type> <name>usage</name></member>
+            <member><type>VkNativeBufferUsage2ANDROID</type> <name>usage2</name></member>
+        </type>
+        <type category="struct" name="VkSwapchainImageCreateInfoANDROID">
+            <member values="VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>* <name>pNext</name></member>
+            <member><type>VkSwapchainImageUsageFlagsANDROID</type> <name>usage</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDevicePresentationPropertiesANDROID">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>* <name>pNext</name></member>
+            <member><type>VkBool32</type> <name>sharedImage</name></member>
         </type>
         <type category="struct" name="VkShaderResourceUsageAMD" returnedonly="true">
             <member><type>uint32_t</type> <name>numUsedVgprs</name></member>
@@ -3147,6 +3175,12 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>uint32_t</type> <name>maxVgprAllocation</name><comment>number of available VGPRs</comment></member>
             <member><type>uint32_t</type> <name>vgprAllocationGranularity</name><comment>VGPRs are allocated in groups of this size</comment></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceShaderCoreProperties2AMD" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*    <name>pNext</name><comment>Pointer to next structure</comment></member>
+            <member><type>VkShaderCorePropertiesFlagsAMD</type> <name>shaderCoreFeatures</name><comment>features supported by the shader core</comment></member>
+            <member><type>uint32_t</type> <name>activeComputeUnitCount</name><comment>number of active compute units across all shader engines/arrays</comment></member>
+        </type>
         <type category="struct" name="VkPipelineRasterizationConservativeStateCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                                                                      <name>pNext</name></member>                 <!-- Pointer to next structure -->
@@ -3836,6 +3870,11 @@ typedef void <name>CAMetalLayer</name>;
             <member optional="true"><type>uint32_t</type>                 <name>attachmentCount</name></member>
             <member len="attachmentCount">const <type>VkImageView</type>* <name>pAttachments</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*            <name>pNext</name></member>                             <!-- Pointer to next structure -->
+            <member><type>VkBool32</type>               <name>textureCompressionASTC_HDR</name></member>        <!-- ASTC HDR texture compression formats -->
+        </type>
         <type category="struct" name="VkPhysicalDeviceCooperativeMatrixFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
             <member><type>void</type>*                               <name>pNext</name></member>
@@ -3926,8 +3965,8 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkSampleCountFlags</type>         <name>depthStencilSamples</name></member>
             <member><type>VkSampleCountFlags</type>         <name>colorSamples</name></member>
         </type>
-        <type category="struct" name="VkPhysicalDeviceShaderIntegerFunctions2INTEL" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
-            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL"><type>VkStructureType</type> <name>sType</name></member>
+        <type category="struct" name="VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"><type>VkStructureType</type> <name>sType</name></member>
             <member><type>void</type>*                            <name>pNext</name></member>
             <member><type>VkBool32</type>                         <name>shaderIntegerFunctions2</name></member>
         </type>
@@ -3974,6 +4013,11 @@ typedef void <name>CAMetalLayer</name>;
             <member>const <type>void</type>*                         <name>pNext</name></member>
             <member><type>VkPerformanceConfigurationTypeINTEL</type> <name>type</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceIndexTypeUint8FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
+            <member><type>VkBool32</type>                           <name>indexTypeUint8</name></member>
+        </type>
         <type category="struct" name="VkPhysicalDeviceShaderSMBuiltinsPropertiesNV" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
             <member><type>void</type>*                          <name>pNext</name></member>
@@ -3992,6 +4036,53 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkBool32</type>               <name>fragmentShaderPixelInterlock</name></member>
             <member><type>VkBool32</type>               <name>fragmentShaderShadingRateInterlock</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*              <name>pNext</name></member>
+            <member><type>VkBool32</type>           <name>pipelineExecutableInfo</name></member>
+        </type>
+        <type category="struct" name="VkPipelineInfoKHR">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*        <name>pNext</name></member>
+            <member><type>VkPipeline</type>         <name>pipeline</name></member>
+        </type>
+        <type category="struct" name="VkPipelineExecutablePropertiesKHR" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*              <name>pNext</name></member>
+            <member><type>VkShaderStageFlags</type> <name>stages</name></member>
+            <member><type>char</type>               <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+            <member><type>char</type>               <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+            <member><type>uint32_t</type>           <name>subgroupSize</name></member>
+        </type>
+        <type category="struct" name="VkPipelineExecutableInfoKHR">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*        <name>pNext</name></member>
+            <member><type>VkPipeline</type>         <name>pipeline</name></member>
+            <member><type>uint32_t</type>           <name>executableIndex</name></member>
+        </type>
+        <type category="union" name="VkPipelineExecutableStatisticValueKHR" returnedonly="true">
+            <member><type>VkBool32</type>           <name>b32</name></member>
+            <member><type>int64_t</type>            <name>i64</name></member>
+            <member><type>uint64_t</type>           <name>u64</name></member>
+            <member><type>double</type>             <name>f64</name></member>
+        </type>
+        <type category="struct" name="VkPipelineExecutableStatisticKHR" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*              <name>pNext</name></member>
+            <member><type>char</type>               <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+            <member><type>char</type>               <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+            <member><type>VkPipelineExecutableStatisticFormatKHR</type> <name>format</name></member>
+            <member><type>VkPipelineExecutableStatisticValueKHR</type>  <name>value</name></member>
+        </type>
+        <type category="struct" name="VkPipelineExecutableInternalRepresentationKHR">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*              <name>pNext</name></member>
+            <member><type>char</type>               <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+            <member><type>char</type>               <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+            <member><type>VkBool32</type>           <name>isText</name></member>
+            <member optional="true"><type>size_t</type>               <name>dataSize</name></member>
+            <member optional="true" len="dataSize"><type>void</type>* <name>pData</name></member>
+        </type>
         <type category="struct" name="VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
@@ -4002,7 +4093,7 @@ typedef void <name>CAMetalLayer</name>;
             <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
             <member><type>VkBool32</type>                           <name>texelBufferAlignment</name></member>
         </type>
-        <type category="struct" name="VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT" structextends="VkPhysicalDeviceMemoryProperties2" returnedonly="true">
+        <type category="struct" name="VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
             <member><type>VkDeviceSize</type>                       <name>storageTexelBufferOffsetAlignmentBytes</name></member>
@@ -4010,6 +4101,58 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkDeviceSize</type>                       <name>uniformTexelBufferOffsetAlignmentBytes</name></member>
             <member><type>VkBool32</type>                           <name>uniformTexelBufferOffsetSingleTexelAlignment</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceSubgroupSizeControlFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+             <member><type>void</type>*                          <name>pNext</name></member>
+             <member><type>VkBool32</type> <name>subgroupSizeControl</name></member>
+             <member><type>VkBool32</type> <name>computeFullSubgroups</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceSubgroupSizeControlPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
+             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+             <member><type>void</type>*                          <name>pNext</name></member>
+             <member noautovalidity="true"><type>uint32_t</type> <name>minSubgroupSize</name><comment>The minimum subgroup size supported by this device</comment></member>
+             <member noautovalidity="true"><type>uint32_t</type> <name>maxSubgroupSize</name><comment>The maximum subgroup size supported by this device</comment></member>
+             <member noautovalidity="true"><type>uint32_t</type> <name>maxComputeWorkgroupSubgroups</name><comment>The maximum number of subgroups supported in a workgroup</comment></member>
+             <member><type>VkShaderStageFlags</type>             <name>requiredSubgroupSizeStages</name><comment>The shader stages that support specifying a subgroup size</comment></member>
+        </type>
+        <type category="struct" name="VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT" returnedonly="true" structextends="VkPipelineShaderStageCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                  <name>pNext</name></member>
+            <member><type>uint32_t</type>               <name>requiredSubgroupSize</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceLineRasterizationFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
+            <member><type>VkBool32</type>                           <name>rectangularLines</name></member>
+            <member><type>VkBool32</type>                           <name>bresenhamLines</name></member>
+            <member><type>VkBool32</type>                           <name>smoothLines</name></member>
+            <member><type>VkBool32</type>                           <name>stippledRectangularLines</name></member>
+            <member><type>VkBool32</type>                           <name>stippledBresenhamLines</name></member>
+            <member><type>VkBool32</type>                           <name>stippledSmoothLines</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceLineRasterizationPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                               <name>pNext</name></member>
+            <member><type>uint32_t</type>                            <name>lineSubPixelPrecisionBits</name></member>
+        </type>
+        <type category="struct" name="VkPipelineRasterizationLineStateCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                                      <name>pNext</name></member>
+            <member><type>VkLineRasterizationModeEXT</type>                                       <name>lineRasterizationMode</name></member>
+            <member><type>VkBool32</type>                                                         <name>stippledLineEnable</name></member>
+            <member optional="true"><type>uint32_t</type>                                         <name>lineStippleFactor</name></member>
+            <member optional="true"><type>uint16_t</type>                                         <name>lineStipplePattern</name></member>
+        </type>
+        <type category="struct" name="VkPipelineCompilerControlCreateInfoAMD" structextends="VkGraphicsPipelineCreateInfo,VkComputePipelineCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"><type>VkStructureType</type>   <name>sType</name></member>
+            <member>const <type>void</type>*                                                                            <name>pNext</name></member>
+            <member optional="true"><type>VkPipelineCompilerControlFlagsAMD</type>                                      <name>compilerControlFlags</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceCoherentMemoryFeaturesAMD" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"><type>VkStructureType</type> <name>sType</name></member>
+            <member noautovalidity="true"><type>void</type>*        <name>pNext</name></member>
+            <member><type>VkBool32</type>                           <name>deviceCoherentMemory</name></member>
+        </type>
     </types>
 
     <comment>Vulkan enumerant (token) definitions</comment>
@@ -4675,6 +4818,8 @@ typedef void <name>CAMetalLayer</name>;
         <enum bitpos="1"    name="VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"/>
         <enum bitpos="2"    name="VK_PIPELINE_CREATE_DERIVATIVE_BIT"/>
     </enums>
+    <enums name="VkPipelineShaderStageCreateFlagBits" type="bitmask">
+    </enums>
     <enums name="VkColorComponentFlagBits" type="bitmask">
         <enum bitpos="0"    name="VK_COLOR_COMPONENT_R_BIT"/>
         <enum bitpos="1"    name="VK_COLOR_COMPONENT_G_BIT"/>
@@ -4784,7 +4929,8 @@ typedef void <name>CAMetalLayer</name>;
     <enums name="VkStencilFaceFlagBits" type="bitmask">
         <enum bitpos="0"    name="VK_STENCIL_FACE_FRONT_BIT"                         comment="Front face"/>
         <enum bitpos="1"    name="VK_STENCIL_FACE_BACK_BIT"                          comment="Back face"/>
-        <enum value="0x00000003" name="VK_STENCIL_FRONT_AND_BACK"                    comment="Front and back faces"/>
+        <enum value="0x00000003" name="VK_STENCIL_FACE_FRONT_AND_BACK"               comment="Front and back faces"/>
+        <enum                    name="VK_STENCIL_FRONT_AND_BACK" alias="VK_STENCIL_FACE_FRONT_AND_BACK" comment="Alias for backwards compatibility"/>
     </enums>
     <enums name="VkDescriptorPoolCreateFlagBits" type="bitmask">
         <enum bitpos="0"    name="VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT" comment="Descriptor sets may be freed individually"/>
@@ -4827,6 +4973,9 @@ typedef void <name>CAMetalLayer</name>;
         <enum bitpos="7"    name="VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"/>
         <enum bitpos="8"    name="VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"/>
     </enums>
+    <enums name="VkSwapchainImageUsageFlagBitsANDROID" type="bitmask">
+      <enum bitpos="0"      name="VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID"/>
+    </enums>
     <enums name="VkTimeDomainEXT" type="enum">
         <enum value="0"     name="VK_TIME_DOMAIN_DEVICE_EXT"/>
         <enum value="1"     name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"/>
@@ -4896,12 +5045,11 @@ typedef void <name>CAMetalLayer</name>;
     <enums name="VkValidationCheckEXT" type="enum">
         <enum value="0"     name="VK_VALIDATION_CHECK_ALL_EXT"/>
         <enum value="1"     name="VK_VALIDATION_CHECK_SHADERS_EXT"/>
-            <comment>Placeholder for validation enums to be defined for VK_EXT_Validation_flags extension</comment>
     </enums>
     <enums name="VkValidationFeatureEnableEXT" type="enum">
         <enum value="0"     name="VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT"/>
         <enum value="1"     name="VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT"/>
-            <comment>Placeholder for validation feature enable enums to be defined for VK_EXT_validation_features extension</comment>
+        <enum value="2"     name="VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT"/>
     </enums>
     <enums name="VkValidationFeatureDisableEXT" type="enum">
         <enum value="0"     name="VK_VALIDATION_FEATURE_DISABLE_ALL_EXT"/>
@@ -4911,7 +5059,6 @@ typedef void <name>CAMetalLayer</name>;
         <enum value="4"     name="VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT"/>
         <enum value="5"     name="VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT"/>
         <enum value="6"     name="VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT"/>
-            <comment>Placeholder for validation feature disable enums to be defined for VK_EXT_validation_features extension</comment>
     </enums>
     <enums name="VkSubgroupFeatureFlagBits" type="bitmask">
         <enum bitpos="0"    name="VK_SUBGROUP_FEATURE_BASIC_BIT"              comment="Basic subgroup operations"/>
@@ -5251,6 +5398,8 @@ typedef void <name>CAMetalLayer</name>;
         <enum value="2"     name="VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT"/>
         <enum value="3"     name="VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT"/>
     </enums>
+    <enums name="VkShaderCorePropertiesFlagBitsAMD" type="bitmask">
+    </enums>
     <enums name="VkPerformanceConfigurationTypeINTEL" type="enum">
         <enum value="0"     name="VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL"/>
     </enums>
@@ -5272,6 +5421,27 @@ typedef void <name>CAMetalLayer</name>;
         <enum value="3"     name="VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL"/>
         <enum value="4"     name="VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL"/>
     </enums>
+    <enums name="VkPipelineExecutableStatisticFormatKHR" type="enum">
+        <enum value="0" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR"/>
+        <enum value="1" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR"/>
+        <enum value="2" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR"/>
+        <enum value="3" name="VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR"/>
+    </enums>
+    <enums name="VkShaderFloatControlsIndependenceKHR" type="enum">
+        <enum value="0"     name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR"/>
+        <enum value="1"     name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR"/>
+        <enum value="2"     name="VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR"/>
+    </enums>
+    <enums name="VkLineRasterizationModeEXT" type="enum">
+        <enum value="0"     name="VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT"/>
+        <enum value="1"     name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT"/>
+        <enum value="2"     name="VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT"/>
+        <enum value="3"     name="VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT"/>
+    </enums>
+    <enums name="VkShaderModuleCreateFlagBits" type="bitmask">
+    </enums>
+    <enums name="VkPipelineCompilerControlFlagBitsAMD" type="bitmask">
+    </enums>
 
     <commands comment="Vulkan command definitions">
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_LAYER_NOT_PRESENT,VK_ERROR_EXTENSION_NOT_PRESENT,VK_ERROR_INCOMPATIBLE_DRIVER">
@@ -7070,6 +7240,15 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>int</type>* <name>grallocUsage</name></param>
         </command>
         <command>
+            <proto><type>VkResult</type> <name>vkGetSwapchainGrallocUsage2ANDROID</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkFormat</type> <name>format</name></param>
+            <param><type>VkImageUsageFlags</type> <name>imageUsage</name></param>
+            <param><type>VkSwapchainImageUsageFlagsANDROID</type> <name>swapchainImageUsage</name></param>
+            <param><type>uint64_t</type>* <name>grallocConsumerUsage</name></param>
+            <param><type>uint64_t</type>* <name>grallocProducerUsage</name></param>
+        </command>
+        <command>
             <proto><type>VkResult</type> <name>vkAcquireImageANDROID</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param><type>VkImage</type> <name>image</name></param>
@@ -7388,14 +7567,14 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>uint32_t</type> <name>bindInfoCount</name></param>
             <param len="bindInfoCount">const <type>VkBindAccelerationStructureMemoryInfoNV</type>* <name>pBindInfos</name></param>
         </command>
-        <command queues="compute" renderpass="both" cmdbufferlevel="primary,secondary">
+        <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdCopyAccelerationStructureNV</name></proto>
             <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>VkAccelerationStructureNV</type> <name>dst</name></param>
             <param><type>VkAccelerationStructureNV</type> <name>src</name></param>
             <param><type>VkCopyAccelerationStructureModeNV</type> <name>mode</name></param>
         </command>
-        <command queues="compute" renderpass="both" cmdbufferlevel="primary,secondary">
+        <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdWriteAccelerationStructuresPropertiesNV</name></proto>
             <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>uint32_t</type> <name>accelerationStructureCount</name></param>
@@ -7404,7 +7583,7 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>VkQueryPool</type> <name>queryPool</name></param>
             <param><type>uint32_t</type> <name>firstQuery</name></param>
         </command>
-        <command queues="compute" renderpass="both" cmdbufferlevel="primary,secondary">
+        <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdBuildAccelerationStructureNV</name></proto>
             <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param>const <type>VkAccelerationStructureInfoNV</type>* <name>pInfo</name></param>
@@ -7416,7 +7595,7 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>VkBuffer</type> <name>scratch</name></param>
             <param><type>VkDeviceSize</type> <name>scratchOffset</name></param>
         </command>
-        <command queues="compute" renderpass="both" cmdbufferlevel="primary,secondary">
+        <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
             <proto><type>void</type> <name>vkCmdTraceRaysNV</name></proto>
             <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
             <param><type>VkBuffer</type> <name>raygenShaderBindingTableBuffer</name></param>
@@ -7563,6 +7742,33 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>VkPerformanceParameterTypeINTEL</type> <name>parameter</name></param>
             <param><type>VkPerformanceValueINTEL</type>* <name>pValue</name></param>
         </command>
+        <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetPipelineExecutablePropertiesKHR</name></proto>
+            <param><type>VkDevice</type>                        <name>device</name></param>
+            <param>const <type>VkPipelineInfoKHR</type>*        <name>pPipelineInfo</name></param>
+            <param optional="false,true"><type>uint32_t</type>* <name>pExecutableCount</name></param>
+            <param optional="true" len="pExecutableCount"><type>VkPipelineExecutablePropertiesKHR</type>* <name>pProperties</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetPipelineExecutableStatisticsKHR</name></proto>
+            <param><type>VkDevice</type>                        <name>device</name></param>
+            <param>const <type>VkPipelineExecutableInfoKHR</type>*  <name>pExecutableInfo</name></param>
+            <param optional="false,true"><type>uint32_t</type>* <name>pStatisticCount</name></param>
+            <param optional="true" len="pStatisticCount"><type>VkPipelineExecutableStatisticKHR</type>* <name>pStatistics</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetPipelineExecutableInternalRepresentationsKHR</name></proto>
+            <param><type>VkDevice</type>                        <name>device</name></param>
+            <param>const <type>VkPipelineExecutableInfoKHR</type>*  <name>pExecutableInfo</name></param>
+            <param optional="false,true"><type>uint32_t</type>* <name>pInternalRepresentationCount</name></param>
+            <param optional="true" len="pInternalRepresentationCount"><type>VkPipelineExecutableInternalRepresentationKHR</type>* <name>pInternalRepresentations</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetLineStippleEXT</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>uint32_t</type> <name>lineStippleFactor</name></param>
+            <param><type>uint16_t</type> <name>lineStipplePattern</name></param>
+        </command>
     </commands>
 
     <feature api="vulkan" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
@@ -8182,7 +8388,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_display" number="3" type="instance" requires="VK_KHR_surface" author="KHR" contact="James Jones @cubanismo,Norbert Nopper @FslNopper" supported="vulkan">
             <require>
-                <enum value="21"                                                name="VK_KHR_DISPLAY_SPEC_VERSION"/>
+                <enum value="23"                                                name="VK_KHR_DISPLAY_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_display&quot;"                        name="VK_KHR_DISPLAY_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR"/>
                 <enum offset="1" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR"/>
@@ -8208,7 +8414,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_display_swapchain" number="4" type="device" requires="VK_KHR_swapchain,VK_KHR_display" author="KHR" contact="James Jones @cubanismo" supported="vulkan">
             <require>
-                <enum value="9"                                                 name="VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION"/>
+                <enum value="10"                                                name="VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_display_swapchain&quot;"              name="VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR"/>
                 <enum offset="1" extends="VkResult" dir="-"                     name="VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"/>
@@ -8281,14 +8487,22 @@ typedef void <name>CAMetalLayer</name>;
         <extension name="VK_ANDROID_native_buffer" number="11" type="device" author="ANDROID" platform="android" contact="Jesse Hall @critsec" supported="disabled">
             <require>
                 <comment>VK_ANDROID_native_buffer is used between the Android Vulkan loader and drivers to implement the WSI extensions. It isn't exposed to applications and uses types that aren't part of Android's stable public API, so it is left disabled to keep it out of the standard Vulkan headers.</comment>
-                <enum value="5"                                                 name="VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION"/>
+                <enum value="8"                                                 name="VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION"/>
                 <enum value="11"                                                name="VK_ANDROID_NATIVE_BUFFER_NUMBER"/>
                 <enum value="&quot;VK_ANDROID_native_buffer&quot;"              name="VK_ANDROID_NATIVE_BUFFER_NAME"/>
                 <enum offset="0" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"/>
+                <enum offset="1" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID"/>
+                <enum offset="2" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID"/>
                 <type name="VkNativeBufferANDROID"/>
+                <type name="VkSwapchainImageCreateInfoANDROID"/>
+                <type name="VkPhysicalDevicePresentationPropertiesANDROID"/>
+                <type name="VkNativeBufferUsage2ANDROID"/>
+                <type name="VkSwapchainImageUsageFlagBitsANDROID"/>
+                <type name="VkSwapchainImageUsageFlagsANDROID"/>
                 <command name="vkGetSwapchainGrallocUsageANDROID"/>
                 <command name="vkAcquireImageANDROID"/>
                 <command name="vkQueueSignalReleaseImageANDROID"/>
+                <command name="vkGetSwapchainGrallocUsage2ANDROID"/>
             </require>
         </extension>
         <extension name="VK_EXT_debug_report" number="12" type="instance" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" supported="vulkan" deprecatedby="VK_EXT_debug_utils">
@@ -8326,9 +8540,10 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_sampler_mirror_clamp_to_edge" type="device" number="15" author="KHR" contact="Tobias Hector @tobski" supported="vulkan">
             <require>
-                <enum value="1"                                                 name="VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION"/>
+                <enum value="3"                                                 name="VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_sampler_mirror_clamp_to_edge&quot;"   name="VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME"/>
                 <enum value="4" extends="VkSamplerAddressMode"                  name="VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" comment="Note that this defines what was previously a core enum, and so uses the 'value' attribute rather than 'offset', and does not have a suffix. This is a special case, and should not be repeated"/>
+                <enum           extends="VkSamplerAddressMode"                  name="VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR" alias="VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" comment="Alias introduced for consistency with extension suffixing rules"/>
             </require>
         </extension>
         <extension name="VK_IMG_filter_cubic" number="16" type="device" author="IMG" contact="Tobias Hector @tobski" supported="vulkan">
@@ -8518,7 +8733,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_AMD_draw_indirect_count" number="34" type="device" author="AMD" contact="Daniel Rakos @drakos-amd" supported="vulkan" promotedto="VK_KHR_draw_indirect_count">
             <require>
-                <enum value="1"                                                 name="VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION"/>
+                <enum value="2"                                                 name="VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION"/>
                 <enum value="&quot;VK_AMD_draw_indirect_count&quot;"            name="VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME"/>
                 <command name="vkCmdDrawIndirectCountAMD"/>
                 <command name="vkCmdDrawIndexedIndirectCountAMD"/>
@@ -8639,10 +8854,12 @@ typedef void <name>CAMetalLayer</name>;
                 <type name="VkPhysicalDeviceCornerSampledImageFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_NVX_extension_52" number="52" author="NVX" contact="James Jones @cubanismo" supported="disabled">
+        <extension name="VK_NV_extension_52" number="52" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
             <require>
-                <enum value="0"                                                 name="VK_NVX_EXTENSION_52_SPEC_VERSION"/>
-                <enum value="&quot;VK_NVX_extension_52&quot;"                   name="VK_NVX_EXTENSION_52_EXTENSION_NAME"/>
+                <enum value="0"                                                 name="VK_NV_EXTENSION_52_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_extension_52&quot;"                    name="VK_NV_EXTENSION_52_EXTENSION_NAME"/>
+                <enum bitpos="0" extends="VkShaderModuleCreateFlagBits"         name="VK_SHADER_MODULE_CREATE_RESERVED_0_BIT_NV"/>
+                <enum bitpos="2" extends="VkPipelineShaderStageCreateFlagBits"  name="VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_2_BIT_NV"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_53" number="53" author="NV" contact="Jeff Bolz @jeffbolznv" supported="disabled">
@@ -8713,7 +8930,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_NV_win32_keyed_mutex" number="59" type="device" requires="VK_NV_external_memory_win32" author="NV" contact="Carsten Rohde @crohde" platform="win32" supported="vulkan" promotedto="VK_KHR_win32_keyed_mutex">
             <require>
-                <enum value="1"                                                 name="VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION"/>
+                <enum value="2"                                                 name="VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_win32_keyed_mutex&quot;"               name="VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"/>
                 <type name="VkWin32KeyedMutexAcquireReleaseInfoNV"/>
@@ -8721,7 +8938,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_get_physical_device_properties2" number="60" type="instance" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_1">
             <require>
-                <enum value="1"                                                 name="VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION"/>
+                <enum value="2"                                                 name="VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_get_physical_device_properties2&quot;" name="VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME"/>
                 <enum extends="VkStructureType"                                 name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"/>
                 <enum extends="VkStructureType"                                 name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"/>
@@ -8752,7 +8969,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_device_group" number="61" type="device" author="KHR" requires="VK_KHR_device_group_creation" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_1">
             <require>
-                <enum value="3"                                                 name="VK_KHR_DEVICE_GROUP_SPEC_VERSION"/>
+                <enum value="4"                                                 name="VK_KHR_DEVICE_GROUP_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_device_group&quot;"                   name="VK_KHR_DEVICE_GROUP_EXTENSION_NAME"/>
                 <enum extends="VkStructureType"                                 name="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR" alias="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"/>
                 <enum extends="VkStructureType"                                 name="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR" alias="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"/>
@@ -8847,10 +9064,26 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_EXT_shader_subgroup_vote&quot;"           name="VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_ARM_extension_01" number="67" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
-            <require>
-                <enum value="0"                                                 name="VK_ARM_EXTENSION_01_SPEC_VERSION"/>
-                <enum value="&quot;VK_ARM_extension_01&quot;"                   name="VK_ARM_EXTENSION_01_EXTENSION_NAME"/>
+        <extension name="VK_EXT_texture_compression_astc_hdr" number="67" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" requires="VK_KHR_get_physical_device_properties2" supported="vulkan">
+            <require>
+                <enum value="1"                                               name="VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_texture_compression_astc_hdr&quot;" name="VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                    name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"/>
+                <type name="VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="0" name="VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="1" name="VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="2" name="VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="3" name="VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="4" name="VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="5" name="VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="6" name="VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="7" name="VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="8" name="VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="9" name="VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="10" name="VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="11" name="VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="12" name="VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT"/>
+                <enum extends="VkFormat" extnumber="67" offset="13" name="VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT"/>
             </require>
         </extension>
         <extension name="VK_EXT_astc_decode_mode" number="68" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" requires="VK_KHR_get_physical_device_properties2" supported="vulkan">
@@ -9058,7 +9291,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_conditional_rendering" number="82" type="device" author="NV" contact="Vikram Kushwaha @vkushwaha" supported="vulkan">
             <require>
-                <enum value="1"                                             name="VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION"/>
+                <enum value="2"                                             name="VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_conditional_rendering&quot;"      name="VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"/>
                 <enum offset="1" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"/>
@@ -9079,7 +9312,9 @@ typedef void <name>CAMetalLayer</name>;
             <require>
                 <enum value="1"                                           name="VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_shader_float16_int8&quot;"      name="VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME"/>
-                <enum offset="0" extends="VkStructureType"                name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR"/>
+                <enum offset="0" extends="VkStructureType"                name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR"/>
+                <enum            extends="VkStructureType"                name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR"/>
+                <type name="VkPhysicalDeviceShaderFloat16Int8FeaturesKHR"/>
                 <type name="VkPhysicalDeviceFloat16Int8FeaturesKHR"/>
             </require>
         </extension>
@@ -9363,7 +9598,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_hdr_metadata" number="106" type="device" requires="VK_KHR_swapchain" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" supported="vulkan">
             <require>
-                <enum value="1"                                             name="VK_EXT_HDR_METADATA_SPEC_VERSION"/>
+                <enum value="2"                                             name="VK_EXT_HDR_METADATA_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_hdr_metadata&quot;"               name="VK_EXT_HDR_METADATA_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_HDR_METADATA_EXT"/>
                 <type name="VkHdrMetadataEXT"/>
@@ -9674,7 +9909,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_sampler_filter_minmax" number="131" type="device" author="NV" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
             <require>
-                <enum value="1"                                             name="VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION"/>
+                <enum value="2"                                             name="VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_sampler_filter_minmax&quot;"      name="VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT"/>
                 <enum offset="1" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT"/>
@@ -9939,7 +10174,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_sampler_ycbcr_conversion" number="157" type="device" requires="VK_KHR_maintenance1,VK_KHR_bind_memory2,VK_KHR_get_memory_requirements2,VK_KHR_get_physical_device_properties2" author="KHR" contact="Andrew Garrard @fluppeteer" supported="vulkan" promotedto="VK_VERSION_1_1">
             <require>
-                <enum value="1"                                             name="VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION"/>
+                <enum value="14"                                            name="VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_sampler_ycbcr_conversion&quot;"   name="VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME"/>
                 <enum extends="VkStructureType"                             name="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR" alias="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"/>
                 <enum extends="VkStructureType"                             name="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR" alias="VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"/>
@@ -10181,6 +10416,7 @@ typedef void <name>CAMetalLayer</name>;
                 <enum offset="0" extends="VkObjectType"                  name="VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"/>
                 <enum offset="0" extends="VkDebugReportObjectTypeEXT"    name="VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT"/>
                 <enum offset="0" extends="VkIndexType"                   name="VK_INDEX_TYPE_NONE_NV"/>
+                <type name="VkAccelerationStructureTypeNV"/>
                 <type name="VkRayTracingShaderGroupCreateInfoNV"/>
                 <type name="VkRayTracingShaderGroupTypeNV"/>
                 <type name="VkRayTracingPipelineCreateInfoNV"/>
@@ -10221,7 +10457,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_NV_representative_fragment_test" number="167" type="device" author="NV" contact="Kedarnath Thangudu @kthangudu" supported="vulkan">
             <require>
-                <enum value="1"                                             name="VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION"/>
+                <enum value="2"                                             name="VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_representative_fragment_test&quot;" name="VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"/>
                 <enum offset="1" extends="VkStructureType"  name="VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"/>
@@ -10360,10 +10596,14 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_AMD_extension_183&quot;"              name="VK_KHR_EXTENSION_183_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_AMD_extension_184" number="184" author="AMD" contact="Daniel Rakos @drakos-amd" supported="disabled">
+        <extension name="VK_AMD_pipeline_compiler_control" number="184" type="device" author="AMD" contact="Matthaeus G. Chajdas @anteru" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_KHR_EXTENSION_184_SPEC_VERSION"/>
-                <enum value="&quot;VK_AMD_extension_184&quot;"              name="VK_KHR_EXTENSION_184_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION"/>
+                <enum value="&quot;VK_AMD_pipeline_compiler_control&quot;"  name="VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"/>
+                <type name="VkPipelineCompilerControlFlagBitsAMD"/>
+                <type name="VkPipelineCompilerControlFlagsAMD"/>
+                <type name="VkPipelineCompilerControlCreateInfoAMD"/>
             </require>
         </extension>
         <extension name="VK_EXT_calibrated_timestamps" number="185" type="device" author="EXT" contact="Daniel Rakos @drakos-amd" supported="vulkan">
@@ -10379,7 +10619,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_AMD_shader_core_properties" number="186" type="device" author="AMD" requires="VK_KHR_get_physical_device_properties2" contact="Martin Dinkov @mdinkov" supported="vulkan">
             <require>
-                <enum value="1"                                          name="VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION"/>
+                <enum value="2"                                          name="VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION"/>
                 <enum value="&quot;VK_AMD_shader_core_properties&quot;"  name="VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"               name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"/>
                 <type name="VkPhysicalDeviceShaderCorePropertiesAMD"/>
@@ -10476,10 +10716,11 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_shader_float_controls" number="198" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Alexander Galazin @alegal-arm" supported="vulkan">
             <require>
-                <enum value="1"                                           name="VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION"/>
+                <enum value="4"                                           name="VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_shader_float_controls&quot;"    name="VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR"/>
                 <type name="VkPhysicalDeviceFloatControlsPropertiesKHR"/>
+                <type name="VkShaderFloatControlsIndependenceKHR"/>
             </require>
         </extension>
         <extension name="VK_NV_shader_subgroup_partitioned" number="199" type="device" requiresCore="1.1" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
@@ -10543,7 +10784,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_NV_shader_image_footprint" number="205" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
             <require>
-                <enum value="1"                                         name="VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION"/>
+                <enum value="2"                                         name="VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_shader_image_footprint&quot;"  name="VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"/>
                 <type name="VkPhysicalDeviceShaderImageFootprintFeaturesNV"/>
@@ -10587,10 +10828,10 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_INTEL_shader_integer_functions2" number="210" type="device" requires="VK_KHR_get_physical_device_properties2" author="INTEL" contact="Ian Romanick @ianromanick" supported="vulkan">
             <require>
-                <enum value="1"                                         name="VK_INTEL_SHADER_INTEGER_FUNCTIONS2_SPEC_VERSION"/>
-                <enum value="&quot;VK_INTEL_shader_integer_functions2&quot;" name="VK_INTEL_SHADER_INTEGER_FUNCTIONS2_EXTENSION_NAME"/>
-                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL"/>
-                <type name="VkPhysicalDeviceShaderIntegerFunctions2INTEL"/>
+                <enum value="1"                                         name="VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION"/>
+                <enum value="&quot;VK_INTEL_shader_integer_functions2&quot;" name="VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"/>
+                <type name="VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"/>
             </require>
         </extension>
         <extension name="VK_INTEL_performance_query" number="211" type="device" author="INTEL" contact="Lionel Landwerlin @llandwerlin" supported="vulkan">
@@ -10630,7 +10871,7 @@ typedef void <name>CAMetalLayer</name>;
                 <command name="vkGetPerformanceParameterINTEL"/>
             </require>
         </extension>
-        <extension name="VK_KHR_vulkan_memory_model" number="212" type="device" author="KHR" contact="Jeff Bolz @jeffbolznv" provisional="true" supported="vulkan">
+        <extension name="VK_KHR_vulkan_memory_model" number="212" type="device" author="KHR" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
             <require>
                 <enum value="3"                                         name="VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_vulkan_memory_model&quot;"    name="VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME"/>
@@ -10750,10 +10991,18 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_GOOGLE_decorate_string&quot;"         name="VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_AMD_extension_226" number="226" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
+        <extension name="VK_EXT_subgroup_size_control" number="226" type="device" requiresCore="1.1" author="EXT" contact="Neil Henning @sheredom" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_AMD_EXTENSION_226_SPEC_VERSION"/>
-                <enum value="&quot;VK_AMD_extension_226&quot;"              name="VK_AMD_EXTENSION_226_EXTENSION_NAME"/>
+                <enum value="2"                                                name="VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_subgroup_size_control&quot;"         name="VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME"/>
+                <type                                                          name="VkPhysicalDeviceSubgroupSizeControlFeaturesEXT"/>
+                <type                                                          name="VkPhysicalDeviceSubgroupSizeControlPropertiesEXT"/>
+                <type                                                          name="VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT"/>
+                <enum offset="0" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"/>
+                <enum offset="1" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"/>
+                <enum offset="2" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"/>
+                <enum bitpos="0" extends="VkPipelineShaderStageCreateFlagBits" name="VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT"/>
+                <enum bitpos="1" extends="VkPipelineShaderStageCreateFlagBits" name="VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT"/>
             </require>
         </extension>
         <extension name="VK_AMD_extension_227" number="227" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
@@ -10762,10 +11011,14 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_AMD_extension_227&quot;"              name="VK_AMD_EXTENSION_227_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_AMD_extension_228" number="228" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
+        <extension name="VK_AMD_shader_core_properties2" number="228" type="device" author="AMD" contact="Matthaeus G. Chajdas @anteru" supported="vulkan" requires="VK_AMD_shader_core_properties">
             <require>
-                <enum value="0"                                             name="VK_AMD_EXTENSION_228_SPEC_VERSION"/>
-                <enum value="&quot;VK_AMD_extension_228&quot;"              name="VK_AMD_EXTENSION_228_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION"/>
+                <enum value="&quot;VK_AMD_shader_core_properties2&quot;"    name="VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"/>
+                <type                                                       name="VkPhysicalDeviceShaderCoreProperties2AMD"/>
+                <type                                                       name="VkShaderCorePropertiesFlagBitsAMD"/>
+                <type                                                       name="VkShaderCorePropertiesFlagsAMD"/>
             </require>
         </extension>
         <extension name="VK_AMD_extension_229" number="229" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
@@ -10774,10 +11027,14 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_AMD_extension_229&quot;"              name="VK_AMD_EXTENSION_229_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_AMD_extension_230" number="230" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
+        <extension name="VK_AMD_device_coherent_memory" number="230" type="device" author="AMD" contact="Tobias Hector @tobski" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_AMD_EXTENSION_230_SPEC_VERSION"/>
-                <enum value="&quot;VK_AMD_extension_230&quot;"              name="VK_AMD_EXTENSION_230_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION"/>
+                <enum value="&quot;VK_AMD_device_coherent_memory&quot;"     name="VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME"/>
+                <enum bitpos="6" extends="VkMemoryPropertyFlagBits"         name="VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD"/>
+                <enum bitpos="7" extends="VkMemoryPropertyFlagBits"         name="VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"/>
+                <type                                                       name="VkPhysicalDeviceCoherentMemoryFeaturesAMD"/>
             </require>
         </extension>
         <extension name="VK_AMD_extension_231" number="231" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
@@ -10908,7 +11165,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_validation_features" number="248" type="instance" author="LUNARG" contact="Karl Schultz @karl-lunarg" supported="vulkan">
             <require>
-                <enum value="1"                                             name="VK_EXT_VALIDATION_FEATURES_SPEC_VERSION"/>
+                <enum value="2"                                             name="VK_EXT_VALIDATION_FEATURES_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_validation_features&quot;"        name="VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"/>
                 <type name="VkValidationFeaturesEXT"/>
@@ -10982,7 +11239,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_full_screen_exclusive" number="256" type="device" author="EXT" requires="VK_KHR_get_physical_device_properties2,VK_KHR_surface,VK_KHR_get_surface_capabilities2,VK_KHR_swapchain" platform="win32" contact="James Jones @cubanismo" supported="vulkan">
             <require>
-                <enum value="3"                                             name="VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION"/>
+                <enum value="4"                                             name="VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_full_screen_exclusive&quot;"      name="VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"/>
                 <enum offset="2" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"/>
@@ -11027,10 +11284,19 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_EXT_extension_259&quot;"              name="VK_EXT_EXTENSION_259_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_extension_260" number="260" author="EXT" contact="Allen Jensen @allenjensen" supported="disabled">
+        <extension name="VK_EXT_line_rasterization" number="260" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_EXT_EXTENSION_260_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_extension_260&quot;"              name="VK_EXT_extension_260"/>
+                <enum value="1"                                             name="VK_EXT_LINE_RASTERIZATION_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_line_rasterization&quot;"         name="VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"/>
+                <enum offset="1" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"/>
+                <enum offset="2" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"/>
+                <enum offset="0" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_LINE_STIPPLE_EXT"/>
+                <type name="VkPhysicalDeviceLineRasterizationFeaturesEXT"/>
+                <type name="VkPhysicalDeviceLineRasterizationPropertiesEXT"/>
+                <type name="VkPipelineRasterizationLineStateCreateInfoEXT"/>
+                <type name="VkLineRasterizationModeEXT"/>
+                <command name="vkCmdSetLineStippleEXT"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_261" number="261" author="NV" contact="Kedarnath Thangudu @kthangudu" supported="disabled">
@@ -11066,10 +11332,13 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_BRCM_extension_265&quot;"             name="VK_BRCM_EXTENSION_265_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_extension_266" number="266" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="disabled">
+        <extension name="VK_EXT_index_type_uint8" number="266" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_EXT_EXTENSION_266_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_extension_266&quot;"              name="VK_EXT_extension_266"/>
+                <enum value="1"                                             name="VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_index_type_uint8&quot;"           name="VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"/>
+                <enum offset="0" extends="VkIndexType"                      name="VK_INDEX_TYPE_UINT8_EXT"/>
+                <type name="VkPhysicalDeviceIndexTypeUint8FeaturesEXT"/>
             </require>
         </extension>
         <extension name="VK_EXT_extension_267" number="267" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="disabled">
@@ -11090,10 +11359,29 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_KHR_extension_269&quot;"              name="VK_KHR_extension_269"/>
             </require>
         </extension>
-        <extension name="VK_INTEL_extension_270" number="270" type="device" author="INTEL" contact="Jason Ekstrand @jekstrand" supported="disabled">
-            <require>
-                <enum value="0"                                             name="VK_INTEL_EXTENSION_270_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_270&quot;"              name="VK_INTEL_extension_270"/>
+        <extension name="VK_KHR_pipeline_executable_properties" number="270" type="device" author="KHR" contact="Jason Ekstrand @jekstrand" supported="vulkan">
+            <require>
+                <enum value="1"                                         name="VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_pipeline_executable_properties&quot;"   name="VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"/>
+                <enum offset="2" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"/>
+                <enum offset="3" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"/>
+                <enum offset="4" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"/>
+                <enum offset="5" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"/>
+                <enum bitpos="6" extends="VkPipelineCreateFlagBits"     name="VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"/>
+                <enum bitpos="7" extends="VkPipelineCreateFlagBits"     name="VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"/>
+                <type name="VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR"/>
+                <type name="VkPipelineInfoKHR"/>
+                <type name="VkPipelineExecutablePropertiesKHR"/>
+                <type name="VkPipelineExecutableInfoKHR"/>
+                <type name="VkPipelineExecutableStatisticFormatKHR"/>
+                <type name="VkPipelineExecutableStatisticValueKHR"/>
+                <type name="VkPipelineExecutableStatisticKHR"/>
+                <type name="VkPipelineExecutableInternalRepresentationKHR"/>
+                <command name="vkGetPipelineExecutablePropertiesKHR"/>
+                <command name="vkGetPipelineExecutableStatisticsKHR"/>
+                <command name="vkGetPipelineExecutableInternalRepresentationsKHR"/>
             </require>
         </extension>
         <extension name="VK_INTEL_extension_271" number="271" type="device" author="INTEL" contact="Jason Ekstrand @jekstrand" supported="disabled">
@@ -11177,7 +11465,8 @@ typedef void <name>CAMetalLayer</name>;
         <extension name="VK_QCOM_extension_283" number="283" type="device" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
             <require>
                 <enum value="0"                                             name="VK_QCOM_EXTENSION_283_SPEC_VERSION"/>
-                <enum value="&quot;VK_QCOM_extension_283&quot;"              name="VK_QCOM_extension_283"/>
+                <enum value="&quot;VK_QCOM_extension_283&quot;"             name="VK_QCOM_extension_283"/>
+                <enum bitpos="1" extends="VkRenderPassCreateFlagBits"       name="VK_RENDER_PASS_RESERVED_BIT_1_QCOM"/>
             </require>
         </extension>
         <extension name="VK_EXT_extension_284" number="284" type="device" author="EXT" contact="Samuel Pitoiset @hakzsam" supported="disabled">
@@ -11186,5 +11475,35 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_EXT_extension_284&quot;"              name="VK_EXT_extension_284"/>
             </require>
         </extension>
+        <extension name="VK_EXT_extension_285" number="285" type="device" author="EXT" contact="Yiwei Zhang @zzyiwei" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_285_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_285&quot;"              name="VK_EXT_extension_285"/>
+            </require>
+        </extension>
+        <extension name="VK_EXT_extension_286" number="286" type="instance" author="EXT" contact="Drew DeVault sir@cmpwn.com" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_286_SPEC_VERSION"/>
+                <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">
+            <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"/>
+            </require>
+        </extension>
+        <extension name="VK_NVX_extension_288" number="288" author="NVX" contact="Liam Middlebrook @liam-middlebrook" supported="disabled">
+            <require>
+                <enum value="0"                                                 name="VK_NVX_EXTENSION_288_SPEC_VERSION"/>
+                <enum value="&quot;VK_NVX_extension_288&quot;"                   name="VK_NVX_EXTENSION_288_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_EXT_extension_289" number="289" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
+            <require>
+                <enum value="0"                                                 name="VK_EXT_EXTENSION_289_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_289&quot;"                  name="VK_EXT_EXTENSION_289_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
 </registry>
diff --git a/registry/vkconventions.py b/registry/vkconventions.py
index 37235c1..7230fa2 100644
--- a/registry/vkconventions.py
+++ b/registry/vkconventions.py
@@ -22,6 +22,10 @@ import re
 from conventions import ConventionsBase
 
 
+# Modified from default implementation - see category_requires_validation() below
+CATEGORIES_REQUIRING_VALIDATION = set(('handle', 'enum', 'bitmask'))
+
+
 class VulkanConventions(ConventionsBase):
     def formatExtension(self, name):
         """Mark up a name as an extension for the spec."""
@@ -38,14 +42,6 @@ class VulkanConventions(ConventionsBase):
         return False
 
     @property
-    def struct_macro(self):
-        return 'sname:'
-
-    @property
-    def external_macro(self):
-        return 'code:'
-
-    @property
     def structtype_member_name(self):
         """Return name of the structure type member"""
         return 'sType'
@@ -89,7 +85,7 @@ class VulkanConventions(ConventionsBase):
         """Return suffix of generated Asciidoctor files"""
         return '.txt'
 
-    def api_name(self, spectype = 'api'):
+    def api_name(self, spectype='api'):
         """Return API or specification name for citations in ref pages.ref
            pages should link to for
 
@@ -113,21 +109,6 @@ class VulkanConventions(ConventionsBase):
         return 'VK_'
 
     @property
-    def api_version_prefix(self):
-        """Return API core version token prefix"""
-        return 'VK_VERSION_'
-
-    @property
-    def KHR_prefix(self):
-        """Return extension name prefix for KHR extensions"""
-        return 'VK_KHR_'
-
-    @property
-    def EXT_prefix(self):
-        """Return extension name prefix for EXT extensions"""
-        return 'VK_EXT_'
-
-    @property
     def write_contacts(self):
         """Return whether contact list should be written to extension appendices"""
         return True
@@ -137,22 +118,10 @@ class VulkanConventions(ConventionsBase):
         """Return whether refpage include should be written to extension appendices"""
         return True
 
-    def writeFeature(self, featureExtraProtect, filename):
-        """Returns True if OutputGenerator.endFeature should write this feature.
-           Used in COutputGenerator
-        """
-        return True
-
-    def requires_error_validation(self, return_type):
-        """Returns True if the return_type element is an API result code
-           requiring error validation.
-        """
-        return False
-
     @property
-    def required_errors(self):
-        """Return a list of required error codes for validation."""
-        return []
+    def member_used_for_unique_vuid(self):
+        """Return the member name used in the VUID-...-...-unique ID."""
+        return self.structtype_member_name
 
     def is_externsync_command(self, protoname):
         """Returns True if the protoname element is an API command requiring
@@ -167,19 +136,7 @@ class VulkanConventions(ConventionsBase):
         """
         return name[0:2].lower() == 'vk' or name[0:6] == 'PFN_vk'
 
-    def is_voidpointer_alias(self, tag, text, tail):
-        """Return True if the declaration components (tag,text,tail) of an
-           element represents a void * type
-        """
-        return tag == 'type' and text == 'void' and tail.startswith('*')
-
-    def make_voidpointer_alias(self, tail):
-        """Reformat a void * declaration to include the API alias macro.
-           Vulkan doesn't have an API alias macro, so do nothing.
-        """
-        return tail
-
-    def specURL(self, spectype = 'api'):
+    def specURL(self, spectype='api'):
         """Return public registry URL which ref pages should link to for the
            current all-extensions HTML specification, so xrefs in the
            asciidoc source that aren't to ref pages can link into it
@@ -232,3 +189,12 @@ class VulkanConventions(ConventionsBase):
         """
         return ('scripts', 'style')
 
+    @property
+    def zero(self):
+        return '`0`'
+
+    def category_requires_validation(self, category):
+        """Return True if the given type 'category' always requires validation.
+
+        Overridden because Vulkan doesn't require "valid" text for basetype in the spec right now."""
+        return category in CATEGORIES_REQUIRING_VALIDATION