Update for Vulkan-Docs 1.1.128v1.1.128

4 files changed, 10373 insertions, 15829 deletions

diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index c56dc79..6caec20 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -56,11 +56,21 @@
 # define VULKAN_HPP_ASSERT   assert
 #endif
 
-#if defined(__linux__) || defined(__APPLE__)
-# include <dlfcn.h>
+#if !defined(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL)
+# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
+#endif
+
+#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
+#  if defined(__linux__) || defined(__APPLE__)
+#   include <dlfcn.h>
+#  endif
+
+#  if defined(_WIN32)
+#   include <windows.h>
+#  endif
 #endif
 
-static_assert( VK_HEADER_VERSION ==  127 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION ==  128 , "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
@@ -1161,6 +1171,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
     }
 
+    VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireProfilingLockKHR( device, pInfo );
+    }
+
     VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
@@ -1928,6 +1943,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
     }
 
+    void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleaseProfilingLockKHR( device );
+    }
+
     VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkResetCommandPool( device, commandPool, flags );
@@ -2207,6 +2227,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
     }
 
+    VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
+    }
+
     VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
@@ -2387,6 +2412,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
     }
 
+    void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
+    }
+
     void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
@@ -4513,6 +4543,82 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class PerformanceCounterScopeKHR
+  {
+    eVkQueryScopeCommandBuffer = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR,
+    eVkQueryScopeRenderPass = VK_QUERY_SCOPE_RENDER_PASS_KHR,
+    eVkQueryScopeCommand = VK_QUERY_SCOPE_COMMAND_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PerformanceCounterScopeKHR value )
+  {
+    switch ( value )
+    {
+      case PerformanceCounterScopeKHR::eVkQueryScopeCommandBuffer : return "VkQueryScopeCommandBuffer";
+      case PerformanceCounterScopeKHR::eVkQueryScopeRenderPass : return "VkQueryScopeRenderPass";
+      case PerformanceCounterScopeKHR::eVkQueryScopeCommand : return "VkQueryScopeCommand";
+      default: return "invalid";
+    }
+  }
+
+  enum class PerformanceCounterStorageKHR
+  {
+    eInt32 = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR,
+    eInt64 = VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR,
+    eUint32 = VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR,
+    eUint64 = VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR,
+    eFloat32 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR,
+    eFloat64 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PerformanceCounterStorageKHR value )
+  {
+    switch ( value )
+    {
+      case PerformanceCounterStorageKHR::eInt32 : return "Int32";
+      case PerformanceCounterStorageKHR::eInt64 : return "Int64";
+      case PerformanceCounterStorageKHR::eUint32 : return "Uint32";
+      case PerformanceCounterStorageKHR::eUint64 : return "Uint64";
+      case PerformanceCounterStorageKHR::eFloat32 : return "Float32";
+      case PerformanceCounterStorageKHR::eFloat64 : return "Float64";
+      default: return "invalid";
+    }
+  }
+
+  enum class PerformanceCounterUnitKHR
+  {
+    eGeneric = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR,
+    ePercentage = VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR,
+    eNanoseconds = VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR,
+    eBytes = VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR,
+    eBytesPerSecond = VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR,
+    eKelvin = VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR,
+    eWatts = VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR,
+    eVolts = VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR,
+    eAmps = VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR,
+    eHertz = VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR,
+    eCycles = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PerformanceCounterUnitKHR value )
+  {
+    switch ( value )
+    {
+      case PerformanceCounterUnitKHR::eGeneric : return "Generic";
+      case PerformanceCounterUnitKHR::ePercentage : return "Percentage";
+      case PerformanceCounterUnitKHR::eNanoseconds : return "Nanoseconds";
+      case PerformanceCounterUnitKHR::eBytes : return "Bytes";
+      case PerformanceCounterUnitKHR::eBytesPerSecond : return "BytesPerSecond";
+      case PerformanceCounterUnitKHR::eKelvin : return "Kelvin";
+      case PerformanceCounterUnitKHR::eWatts : return "Watts";
+      case PerformanceCounterUnitKHR::eVolts : return "Volts";
+      case PerformanceCounterUnitKHR::eAmps : return "Amps";
+      case PerformanceCounterUnitKHR::eHertz : return "Hertz";
+      case PerformanceCounterUnitKHR::eCycles : return "Cycles";
+      default: return "invalid";
+    }
+  }
+
   enum class PerformanceOverrideTypeINTEL
   {
     eNullHardware = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL,
@@ -4757,6 +4863,7 @@ namespace VULKAN_HPP_NAMESPACE
     ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
     eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
     eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT,
+    ePerformanceQueryKHR = VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR,
     eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV,
     ePerformanceQueryINTEL = VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL
   };
@@ -4769,6 +4876,7 @@ namespace VULKAN_HPP_NAMESPACE
       case QueryType::ePipelineStatistics : return "PipelineStatistics";
       case QueryType::eTimestamp : return "Timestamp";
       case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT";
+      case QueryType::ePerformanceQueryKHR : return "PerformanceQueryKHR";
       case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV";
       case QueryType::ePerformanceQueryINTEL : return "PerformanceQueryINTEL";
       default: return "invalid";
@@ -5377,6 +5485,13 @@ namespace VULKAN_HPP_NAMESPACE
     eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR,
     eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
     eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR,
+    ePhysicalDevicePerformanceQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
+    ePhysicalDevicePerformanceQueryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
+    eQueryPoolPerformanceCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
+    ePerformanceQuerySubmitInfoKHR = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
+    eAcquireProfilingLockInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR,
+    ePerformanceCounterKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR,
+    ePerformanceCounterDescriptionKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR,
     ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
     eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR,
     eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR,
@@ -5832,6 +5947,13 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eFenceGetWin32HandleInfoKHR : return "FenceGetWin32HandleInfoKHR";
       case StructureType::eImportFenceFdInfoKHR : return "ImportFenceFdInfoKHR";
       case StructureType::eFenceGetFdInfoKHR : return "FenceGetFdInfoKHR";
+      case StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR : return "PhysicalDevicePerformanceQueryFeaturesKHR";
+      case StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR : return "PhysicalDevicePerformanceQueryPropertiesKHR";
+      case StructureType::eQueryPoolPerformanceCreateInfoKHR : return "QueryPoolPerformanceCreateInfoKHR";
+      case StructureType::ePerformanceQuerySubmitInfoKHR : return "PerformanceQuerySubmitInfoKHR";
+      case StructureType::eAcquireProfilingLockInfoKHR : return "AcquireProfilingLockInfoKHR";
+      case StructureType::ePerformanceCounterKHR : return "PerformanceCounterKHR";
+      case StructureType::ePerformanceCounterDescriptionKHR : return "PerformanceCounterDescriptionKHR";
       case StructureType::ePhysicalDeviceSurfaceInfo2KHR : return "PhysicalDeviceSurfaceInfo2KHR";
       case StructureType::eSurfaceCapabilities2KHR : return "SurfaceCapabilities2KHR";
       case StructureType::eSurfaceFormat2KHR : return "SurfaceFormat2KHR";
@@ -6367,6 +6489,21 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+  enum class AcquireProfilingLockFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using AcquireProfilingLockFlagsKHR = Flags<AcquireProfilingLockFlagBitsKHR, VkAcquireProfilingLockFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagsKHR  )
+  {
+    return "{}";
+  }
+
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   enum class AndroidSurfaceCreateFlagBitsKHR
   {};
@@ -10090,6 +10227,72 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
+  enum class PerformanceCounterDescriptionFlagBitsKHR
+  {
+    ePerformanceImpacting = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR,
+    eConcurrentlyImpacted = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagBitsKHR value )
+  {
+    switch ( value )
+    {
+      case PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting : return "PerformanceImpacting";
+      case PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted : return "ConcurrentlyImpacted";
+      default: return "invalid";
+    }
+  }
+
+  using PerformanceCounterDescriptionFlagsKHR = Flags<PerformanceCounterDescriptionFlagBitsKHR, VkPerformanceCounterDescriptionFlagsKHR>;
+
+  template <> struct FlagTraits<PerformanceCounterDescriptionFlagBitsKHR>
+  {
+    enum
+    {
+      allFlags = VkFlags(PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting) | VkFlags(PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted)
+    };
+  };
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR operator|( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+  {
+    return PerformanceCounterDescriptionFlagsKHR( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR operator&( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+  {
+    return PerformanceCounterDescriptionFlagsKHR( bit0 ) & bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR operator^( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+  {
+    return PerformanceCounterDescriptionFlagsKHR( bit0 ) ^ bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR operator~( PerformanceCounterDescriptionFlagBitsKHR bits ) VULKAN_HPP_NOEXCEPT
+  {
+    return ~( PerformanceCounterDescriptionFlagsKHR( bits ) );
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+  {
+    return PerformanceCounterDescriptionFlagsKHR( bit0 ) == bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+  {
+    return PerformanceCounterDescriptionFlagsKHR( bit0 ) != bit1;
+  }
+
+  VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting ) result += "PerformanceImpacting | ";
+    if ( value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted ) result += "ConcurrentlyImpacted | ";
+    return "{ " + result.substr(0, result.size() - 3) + " }";
+  }
+
   enum class PipelineCacheCreateFlagBits
   {};
 
@@ -10186,7 +10389,7 @@ namespace VULKAN_HPP_NAMESPACE
     eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
     eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
     eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
-    eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE,
+    eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
     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,
@@ -12572,7 +12775,7 @@ namespace VULKAN_HPP_NAMESPACE
       : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
   };
 
-  VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
+  [[noreturn]] static void throwResultException( Result result, char const * message )
   {
     switch ( result )
     {
@@ -12736,6 +12939,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct AccelerationStructureInfoNV;
   struct AccelerationStructureMemoryRequirementsInfoNV;
   struct AcquireNextImageInfoKHR;
+  struct AcquireProfilingLockInfoKHR;
   struct AllocationCallbacks;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   struct AndroidHardwareBufferFormatPropertiesANDROID;
@@ -13046,8 +13250,12 @@ namespace VULKAN_HPP_NAMESPACE
   struct Offset3D;
   struct PastPresentationTimingGOOGLE;
   struct PerformanceConfigurationAcquireInfoINTEL;
+  struct PerformanceCounterDescriptionKHR;
+  struct PerformanceCounterKHR;
+  union PerformanceCounterResultKHR;
   struct PerformanceMarkerInfoINTEL;
   struct PerformanceOverrideInfoINTEL;
+  struct PerformanceQuerySubmitInfoKHR;
   struct PerformanceStreamMarkerInfoINTEL;
   union PerformanceValueDataINTEL;
   struct PerformanceValueINTEL;
@@ -13123,6 +13331,8 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceMultiviewProperties;
   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
   struct PhysicalDevicePCIBusInfoPropertiesEXT;
+  struct PhysicalDevicePerformanceQueryFeaturesKHR;
+  struct PhysicalDevicePerformanceQueryPropertiesKHR;
   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
   struct PhysicalDevicePointClippingProperties;
   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
@@ -13234,6 +13444,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PushConstantRange;
   struct QueryPoolCreateInfo;
   struct QueryPoolCreateInfoINTEL;
+  struct QueryPoolPerformanceCreateInfoKHR;
   struct QueueFamilyCheckpointPropertiesNV;
   struct QueueFamilyProperties;
   struct QueueFamilyProperties2;
@@ -16593,6 +16804,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Result acquireProfilingLockKHR( const vk::AcquireProfilingLockInfoKHR* pInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    ResultValueType<void>::type acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     Result allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -18027,6 +18245,10 @@ namespace VULKAN_HPP_NAMESPACE
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     ResultValueType<vk::Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -18034,6 +18256,10 @@ namespace VULKAN_HPP_NAMESPACE
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     ResultValueType<vk::Fence>::type registerDisplayEventEXT( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type registerDisplayEventEXTUnique( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -18061,6 +18287,9 @@ namespace VULKAN_HPP_NAMESPACE
     ResultValueType<void>::type releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void releaseProfilingLockKHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     Result resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
@@ -18381,6 +18610,15 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Result enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, uint32_t* pCounterCount, vk::PerformanceCounterKHR* pCounters, vk::PerformanceCounterDescriptionKHR* pCounterDescriptions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR,Allocator>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy<vk::PerformanceCounterKHR> counters, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+    template<typename Allocator = std::allocator<PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR,Allocator>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy<vk::PerformanceCounterKHR> counters, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     Result getDisplayModeProperties2KHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModeProperties2KHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -18673,6 +18911,13 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getQueueFamilyPerformanceQueryPassesKHR( const vk::QueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    uint32_t getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -19296,65 +19541,7 @@ namespace VULKAN_HPP_NAMESPACE
   ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  namespace layout
-  {
-    struct GeometryTrianglesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : 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 ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkGeometryTrianglesNV*>(this) = rhs;
-      }
-
-      GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct GeometryTrianglesNV
   {
     VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(),
                                               vk::DeviceSize vertexOffset_ = 0,
@@ -19367,16 +19554,33 @@ namespace VULKAN_HPP_NAMESPACE
                                               vk::IndexType indexType_ = vk::IndexType::eUint16,
                                               vk::Buffer transformData_ = vk::Buffer(),
                                               vk::DeviceSize transformOffset_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::GeometryTrianglesNV( vertexData_, vertexOffset_, vertexCount_, vertexStride_, vertexFormat_, indexData_, indexOffset_, indexCount_, indexType_, transformData_, transformOffset_ )
+      : vertexData( vertexData_ )
+      , vertexOffset( vertexOffset_ )
+      , vertexCount( vertexCount_ )
+      , vertexStride( vertexStride_ )
+      , vertexFormat( vertexFormat_ )
+      , indexData( indexData_ )
+      , indexOffset( indexOffset_ )
+      , indexCount( indexCount_ )
+      , indexType( indexType_ )
+      , transformData( transformData_ )
+      , transformOffset( transformOffset_ )
     {}
 
+    vk::GeometryTrianglesNV & operator=( vk::GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryTrianglesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::GeometryTrianglesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::GeometryTrianglesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::GeometryTrianglesNV const *>(&rhs);
       return *this;
     }
 
@@ -19484,65 +19688,50 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::GeometryTrianglesNV::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeometryTrianglesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct GeometryAABBNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(),
-                                           uint32_t numAABBs_ = 0,
-                                           uint32_t stride_ = 0,
-                                           vk::DeviceSize offset_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : aabbData( aabbData_ )
-        , numAABBs( numAABBs_ )
-        , stride( stride_ )
-        , offset( offset_ )
-      {}
-
-      GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkGeometryAABBNV*>(this) = rhs;
-      }
-
-      GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct GeometryAABBNV
   {
     VULKAN_HPP_CONSTEXPR GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(),
                                          uint32_t numAABBs_ = 0,
                                          uint32_t stride_ = 0,
                                          vk::DeviceSize offset_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::GeometryAABBNV( aabbData_, numAABBs_, stride_, offset_ )
+      : aabbData( aabbData_ )
+      , numAABBs( numAABBs_ )
+      , stride( stride_ )
+      , offset( offset_ )
     {}
 
+    vk::GeometryAABBNV & operator=( vk::GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryAABBNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::GeometryAABBNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::GeometryAABBNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::GeometryAABBNV const *>(&rhs);
       return *this;
     }
 
@@ -19601,8 +19790,13 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::GeometryAABBNV::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeometryAABBNV>::value, "struct wrapper is not a standard layout!" );
@@ -19617,12 +19811,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkGeometryDataNV*>(this) = rhs;
+      *this = rhs;
     }
 
     GeometryDataNV& operator=( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkGeometryDataNV*>(this) = rhs;
+      *this = *reinterpret_cast<vk::GeometryDataNV const *>(&rhs);
       return *this;
     }
 
@@ -19666,55 +19860,30 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles,
-                                       vk::GeometryDataNV geometry_ = vk::GeometryDataNV(),
-                                       vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() ) VULKAN_HPP_NOEXCEPT
-        : geometryType( geometryType_ )
-        , geometry( geometry_ )
-        , flags( flags_ )
-      {}
-
-      GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkGeometryNV*>(this) = rhs;
-      }
-
-      GeometryNV& operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkGeometryNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct GeometryNV
   {
     VULKAN_HPP_CONSTEXPR GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles,
                                      vk::GeometryDataNV geometry_ = vk::GeometryDataNV(),
                                      vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() ) VULKAN_HPP_NOEXCEPT
-      : layout::GeometryNV( geometryType_, geometry_, flags_ )
+      : geometryType( geometryType_ )
+      , geometry( geometry_ )
+      , flags( flags_ )
     {}
 
+    vk::GeometryNV & operator=( vk::GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::GeometryNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     GeometryNV& operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::GeometryNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::GeometryNV const *>(&rhs);
       return *this;
     }
 
@@ -19766,69 +19935,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::GeometryNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eGeometryNV;
+    const void* pNext = nullptr;
+    vk::GeometryTypeNV geometryType;
+    vk::GeometryDataNV geometry;
+    vk::GeometryFlagsNV flags;
   };
   static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GeometryNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct AccelerationStructureInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : type( type_ )
-        , flags( flags_ )
-        , instanceCount( instanceCount_ )
-        , geometryCount( geometryCount_ )
-        , pGeometries( pGeometries_ )
-      {}
-
-      AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAccelerationStructureInfoNV*>(this) = rhs;
-      }
-
-      AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct AccelerationStructureInfoNV
   {
     VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-      : layout::AccelerationStructureInfoNV( type_, flags_, instanceCount_, geometryCount_, pGeometries_ )
+      : type( type_ )
+      , flags( flags_ )
+      , instanceCount( instanceCount_ )
+      , geometryCount( geometryCount_ )
+      , pGeometries( pGeometries_ )
     {}
 
+    vk::AccelerationStructureInfoNV & operator=( vk::AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AccelerationStructureInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AccelerationStructureInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::AccelerationStructureInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -19894,57 +20038,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AccelerationStructureInfoNV::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0,
-                                                              vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() ) VULKAN_HPP_NOEXCEPT
-        : compactedSize( compactedSize_ )
-        , info( info_ )
-      {}
-
-      AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this) = rhs;
-      }
-
-      AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct AccelerationStructureCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0,
                                                             vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() ) VULKAN_HPP_NOEXCEPT
-      : layout::AccelerationStructureCreateInfoNV( compactedSize_, info_ )
+      : compactedSize( compactedSize_ )
+      , info( info_ )
     {}
 
+    vk::AccelerationStructureCreateInfoNV & operator=( vk::AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AccelerationStructureCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AccelerationStructureCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::AccelerationStructureCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -19989,57 +20116,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AccelerationStructureCreateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
+    const void* pNext = nullptr;
+    vk::DeviceSize compactedSize;
+    vk::AccelerationStructureInfoNV info;
   };
   static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct AccelerationStructureMemoryRequirementsInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject,
-                                                                          vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() ) VULKAN_HPP_NOEXCEPT
-        : type( type_ )
-        , accelerationStructure( accelerationStructure_ )
-      {}
-
-      AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this) = rhs;
-      }
-
-      AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::AccelerationStructureMemoryRequirementsInfoNV
+  struct AccelerationStructureMemoryRequirementsInfoNV
   {
     VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject,
                                                                         vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() ) VULKAN_HPP_NOEXCEPT
-      : layout::AccelerationStructureMemoryRequirementsInfoNV( type_, accelerationStructure_ )
+      : type( type_ )
+      , accelerationStructure( accelerationStructure_ )
     {}
 
+    vk::AccelerationStructureMemoryRequirementsInfoNV & operator=( vk::AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureMemoryRequirementsInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AccelerationStructureMemoryRequirementsInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AccelerationStructureMemoryRequirementsInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::AccelerationStructureMemoryRequirementsInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -20084,69 +20191,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AccelerationStructureMemoryRequirementsInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
+    const void* pNext = nullptr;
+    vk::AccelerationStructureMemoryRequirementsTypeNV type;
+    vk::AccelerationStructureNV accelerationStructure;
   };
   static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AccelerationStructureMemoryRequirementsInfoNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct AcquireNextImageInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
-                                                    uint64_t timeout_ = 0,
-                                                    vk::Semaphore semaphore_ = vk::Semaphore(),
-                                                    vk::Fence fence_ = vk::Fence(),
-                                                    uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : swapchain( swapchain_ )
-        , timeout( timeout_ )
-        , semaphore( semaphore_ )
-        , fence( fence_ )
-        , deviceMask( deviceMask_ )
-      {}
-
-      AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this) = rhs;
-      }
-
-      AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct AcquireNextImageInfoKHR
   {
     VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
                                                   uint64_t timeout_ = 0,
                                                   vk::Semaphore semaphore_ = vk::Semaphore(),
                                                   vk::Fence fence_ = vk::Fence(),
                                                   uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::AcquireNextImageInfoKHR( swapchain_, timeout_, semaphore_, fence_, deviceMask_ )
+      : swapchain( swapchain_ )
+      , timeout( timeout_ )
+      , semaphore( semaphore_ )
+      , fence( fence_ )
+      , deviceMask( deviceMask_ )
     {}
 
+    vk::AcquireNextImageInfoKHR & operator=( vk::AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AcquireNextImageInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AcquireNextImageInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AcquireNextImageInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::AcquireNextImageInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -20212,12 +20293,93 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AcquireNextImageInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AcquireNextImageInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
+  struct AcquireProfilingLockInfoKHR
+  {
+    VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( vk::AcquireProfilingLockFlagsKHR flags_ = vk::AcquireProfilingLockFlagsKHR(),
+                                                      uint64_t timeout_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : flags( flags_ )
+      , timeout( timeout_ )
+    {}
+
+    vk::AcquireProfilingLockInfoKHR & operator=( vk::AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AcquireProfilingLockInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
+    AcquireProfilingLockInfoKHR( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+    AcquireProfilingLockInfoKHR& operator=( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<vk::AcquireProfilingLockInfoKHR const *>(&rhs);
+      return *this;
+    }
+
+    AcquireProfilingLockInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AcquireProfilingLockInfoKHR & setFlags( vk::AcquireProfilingLockFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    AcquireProfilingLockInfoKHR & setTimeout( uint64_t timeout_ ) VULKAN_HPP_NOEXCEPT
+    {
+      timeout = timeout_;
+      return *this;
+    }
+
+    operator VkAcquireProfilingLockInfoKHR const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>( this );
+    }
+
+    operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkAcquireProfilingLockInfoKHR*>( this );
+    }
+
+    bool operator==( AcquireProfilingLockInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( timeout == rhs.timeout );
+    }
+
+    bool operator!=( AcquireProfilingLockInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    const vk::StructureType sType = StructureType::eAcquireProfilingLockInfoKHR;
+    const void* pNext = nullptr;
+    vk::AcquireProfilingLockFlagsKHR flags;
+    uint64_t timeout;
+  };
+  static_assert( sizeof( AcquireProfilingLockInfoKHR ) == sizeof( VkAcquireProfilingLockInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<AcquireProfilingLockInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
   struct AllocationCallbacks
   {
     VULKAN_HPP_CONSTEXPR AllocationCallbacks( void* pUserData_ = nullptr,
@@ -20236,12 +20398,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkAllocationCallbacks*>(this) = rhs;
+      *this = rhs;
     }
 
     AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkAllocationCallbacks*>(this) = rhs;
+      *this = *reinterpret_cast<vk::AllocationCallbacks const *>(&rhs);
       return *this;
     }
 
@@ -20331,12 +20493,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkComponentMapping*>(this) = rhs;
+      *this = rhs;
     }
 
     ComponentMapping& operator=( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkComponentMapping*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ComponentMapping const *>(&rhs);
       return *this;
     }
 
@@ -20398,53 +20560,40 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
-  namespace layout
-  {
-    struct AndroidHardwareBufferFormatPropertiesANDROID
-    {
-    protected:
-      AndroidHardwareBufferFormatPropertiesANDROID() VULKAN_HPP_NOEXCEPT
-      {}
-
-      AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this) = rhs;
-      }
-
-      AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct AndroidHardwareBufferFormatPropertiesANDROID
   {
-    AndroidHardwareBufferFormatPropertiesANDROID() VULKAN_HPP_NOEXCEPT
-      : layout::AndroidHardwareBufferFormatPropertiesANDROID()
+    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 ) VULKAN_HPP_NOEXCEPT
+      : format( format_ )
+      , externalFormat( externalFormat_ )
+      , formatFeatures( formatFeatures_ )
+      , samplerYcbcrConversionComponents( samplerYcbcrConversionComponents_ )
+      , suggestedYcbcrModel( suggestedYcbcrModel_ )
+      , suggestedYcbcrRange( suggestedYcbcrRange_ )
+      , suggestedXChromaOffset( suggestedXChromaOffset_ )
+      , suggestedYChromaOffset( suggestedYChromaOffset_ )
     {}
 
+    vk::AndroidHardwareBufferFormatPropertiesANDROID & operator=( vk::AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferFormatPropertiesANDROID ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AndroidHardwareBufferFormatPropertiesANDROID( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AndroidHardwareBufferFormatPropertiesANDROID::operator=(rhs);
+      *this = *reinterpret_cast<vk::AndroidHardwareBufferFormatPropertiesANDROID const *>(&rhs);
       return *this;
     }
 
@@ -20477,8 +20626,17 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AndroidHardwareBufferFormatPropertiesANDROID::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AndroidHardwareBufferFormatPropertiesANDROID>::value, "struct wrapper is not a standard layout!" );
@@ -20486,47 +20644,28 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
-  namespace layout
-  {
-    struct AndroidHardwareBufferPropertiesANDROID
-    {
-    protected:
-      AndroidHardwareBufferPropertiesANDROID() VULKAN_HPP_NOEXCEPT
-      {}
-
-      AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this) = rhs;
-      }
-
-      AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct AndroidHardwareBufferPropertiesANDROID
   {
-    AndroidHardwareBufferPropertiesANDROID() VULKAN_HPP_NOEXCEPT
-      : layout::AndroidHardwareBufferPropertiesANDROID()
+    AndroidHardwareBufferPropertiesANDROID( vk::DeviceSize allocationSize_ = 0,
+                                            uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : allocationSize( allocationSize_ )
+      , memoryTypeBits( memoryTypeBits_ )
     {}
 
+    vk::AndroidHardwareBufferPropertiesANDROID & operator=( vk::AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferPropertiesANDROID ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AndroidHardwareBufferPropertiesANDROID( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AndroidHardwareBufferPropertiesANDROID::operator=(rhs);
+      *this = *reinterpret_cast<vk::AndroidHardwareBufferPropertiesANDROID const *>(&rhs);
       return *this;
     }
 
@@ -20553,8 +20692,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AndroidHardwareBufferPropertiesANDROID::sType;
+  public:
+    const vk::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
+    void* pNext = nullptr;
+    vk::DeviceSize allocationSize;
+    uint32_t memoryTypeBits;
   };
   static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AndroidHardwareBufferPropertiesANDROID>::value, "struct wrapper is not a standard layout!" );
@@ -20562,46 +20704,26 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
-  namespace layout
-  {
-    struct AndroidHardwareBufferUsageANDROID
-    {
-    protected:
-      AndroidHardwareBufferUsageANDROID() VULKAN_HPP_NOEXCEPT
-      {}
-
-      AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this) = rhs;
-      }
-
-      AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct AndroidHardwareBufferUsageANDROID
   {
-    AndroidHardwareBufferUsageANDROID() VULKAN_HPP_NOEXCEPT
-      : layout::AndroidHardwareBufferUsageANDROID()
+    AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : androidHardwareBufferUsage( androidHardwareBufferUsage_ )
     {}
 
+    vk::AndroidHardwareBufferUsageANDROID & operator=( vk::AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferUsageANDROID ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AndroidHardwareBufferUsageANDROID( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AndroidHardwareBufferUsageANDROID::operator=(rhs);
+      *this = *reinterpret_cast<vk::AndroidHardwareBufferUsageANDROID const *>(&rhs);
       return *this;
     }
 
@@ -20627,8 +20749,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AndroidHardwareBufferUsageANDROID::sType;
+  public:
+    const vk::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID;
+    void* pNext = nullptr;
+    uint64_t androidHardwareBufferUsage;
   };
   static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AndroidHardwareBufferUsageANDROID>::value, "struct wrapper is not a standard layout!" );
@@ -20636,51 +20760,28 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
-  namespace layout
-  {
-    struct AndroidSurfaceCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(),
-                                                        struct ANativeWindow* window_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , window( window_ )
-      {}
-
-      AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this) = rhs;
-      }
-
-      AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct AndroidSurfaceCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(),
                                                       struct ANativeWindow* window_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::AndroidSurfaceCreateInfoKHR( flags_, window_ )
+      : flags( flags_ )
+      , window( window_ )
     {}
 
+    vk::AndroidSurfaceCreateInfoKHR & operator=( vk::AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AndroidSurfaceCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AndroidSurfaceCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::AndroidSurfaceCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -20725,70 +20826,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AndroidSurfaceCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
+    const void* pNext = nullptr;
+    vk::AndroidSurfaceCreateFlagsKHR flags;
+    struct ANativeWindow* window;
   };
   static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AndroidSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  namespace layout
-  {
-    struct ApplicationInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = nullptr,
-                                            uint32_t applicationVersion_ = 0,
-                                            const char* pEngineName_ = nullptr,
-                                            uint32_t engineVersion_ = 0,
-                                            uint32_t apiVersion_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : pApplicationName( pApplicationName_ )
-        , applicationVersion( applicationVersion_ )
-        , pEngineName( pEngineName_ )
-        , engineVersion( engineVersion_ )
-        , apiVersion( apiVersion_ )
-      {}
-
-      ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkApplicationInfo*>(this) = rhs;
-      }
-
-      ApplicationInfo& operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ApplicationInfo
   {
     VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = nullptr,
                                           uint32_t applicationVersion_ = 0,
                                           const char* pEngineName_ = nullptr,
                                           uint32_t engineVersion_ = 0,
                                           uint32_t apiVersion_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ApplicationInfo( pApplicationName_, applicationVersion_, pEngineName_, engineVersion_, apiVersion_ )
+      : pApplicationName( pApplicationName_ )
+      , applicationVersion( applicationVersion_ )
+      , pEngineName( pEngineName_ )
+      , engineVersion( engineVersion_ )
+      , apiVersion( apiVersion_ )
     {}
 
+    vk::ApplicationInfo & operator=( vk::ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ApplicationInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ApplicationInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ApplicationInfo& operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ApplicationInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ApplicationInfo const *>(&rhs);
       return *this;
     }
 
@@ -20854,8 +20929,14 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ApplicationInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ApplicationInfo>::value, "struct wrapper is not a standard layout!" );
@@ -20884,12 +20965,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkAttachmentDescription*>(this) = rhs;
+      *this = rhs;
     }
 
     AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkAttachmentDescription*>(this) = rhs;
+      *this = *reinterpret_cast<vk::AttachmentDescription const *>(&rhs);
       return *this;
     }
 
@@ -20989,59 +21070,7 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct AttachmentDescription2KHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , format( format_ )
-        , samples( samples_ )
-        , loadOp( loadOp_ )
-        , storeOp( storeOp_ )
-        , stencilLoadOp( stencilLoadOp_ )
-        , stencilStoreOp( stencilStoreOp_ )
-        , initialLayout( initialLayout_ )
-        , finalLayout( finalLayout_ )
-      {}
-
-      AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAttachmentDescription2KHR*>(this) = rhs;
-      }
-
-      AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct AttachmentDescription2KHR
   {
     VULKAN_HPP_CONSTEXPR AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(),
                                                     vk::Format format_ = vk::Format::eUndefined,
@@ -21052,16 +21081,31 @@ namespace VULKAN_HPP_NAMESPACE
                                                     vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore,
                                                     vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined,
                                                     vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
-      : layout::AttachmentDescription2KHR( flags_, format_, samples_, loadOp_, storeOp_, stencilLoadOp_, stencilStoreOp_, initialLayout_, finalLayout_ )
+      : flags( flags_ )
+      , format( format_ )
+      , samples( samples_ )
+      , loadOp( loadOp_ )
+      , storeOp( storeOp_ )
+      , stencilLoadOp( stencilLoadOp_ )
+      , stencilStoreOp( stencilStoreOp_ )
+      , initialLayout( initialLayout_ )
+      , finalLayout( finalLayout_ )
     {}
 
+    vk::AttachmentDescription2KHR & operator=( vk::AttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentDescription2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AttachmentDescription2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AttachmentDescription2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::AttachmentDescription2KHR const *>(&rhs);
       return *this;
     }
 
@@ -21155,57 +21199,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AttachmentDescription2KHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentDescription2KHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct AttachmentDescriptionStencilLayoutKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayoutKHR( vk::ImageLayout stencilInitialLayout_ = vk::ImageLayout::eUndefined,
-                                                                  vk::ImageLayout stencilFinalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
-        : stencilInitialLayout( stencilInitialLayout_ )
-        , stencilFinalLayout( stencilFinalLayout_ )
-      {}
-
-      AttachmentDescriptionStencilLayoutKHR( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAttachmentDescriptionStencilLayoutKHR*>(this) = rhs;
-      }
-
-      AttachmentDescriptionStencilLayoutKHR& operator=( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAttachmentDescriptionStencilLayoutKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::eAttachmentDescriptionStencilLayoutKHR;
-      void* pNext = nullptr;
-      vk::ImageLayout stencilInitialLayout;
-      vk::ImageLayout stencilFinalLayout;
-    };
-    static_assert( sizeof( AttachmentDescriptionStencilLayoutKHR ) == sizeof( VkAttachmentDescriptionStencilLayoutKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct AttachmentDescriptionStencilLayoutKHR : public layout::AttachmentDescriptionStencilLayoutKHR
+  struct AttachmentDescriptionStencilLayoutKHR
   {
     VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayoutKHR( vk::ImageLayout stencilInitialLayout_ = vk::ImageLayout::eUndefined,
                                                                 vk::ImageLayout stencilFinalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
-      : layout::AttachmentDescriptionStencilLayoutKHR( stencilInitialLayout_, stencilFinalLayout_ )
+      : stencilInitialLayout( stencilInitialLayout_ )
+      , stencilFinalLayout( stencilFinalLayout_ )
     {}
 
+    vk::AttachmentDescriptionStencilLayoutKHR & operator=( vk::AttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentDescriptionStencilLayoutKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AttachmentDescriptionStencilLayoutKHR( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AttachmentDescriptionStencilLayoutKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AttachmentDescriptionStencilLayoutKHR& operator=( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AttachmentDescriptionStencilLayoutKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::AttachmentDescriptionStencilLayoutKHR const *>(&rhs);
       return *this;
     }
 
@@ -21250,8 +21281,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AttachmentDescriptionStencilLayoutKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eAttachmentDescriptionStencilLayoutKHR;
+    void* pNext = nullptr;
+    vk::ImageLayout stencilInitialLayout;
+    vk::ImageLayout stencilFinalLayout;
   };
   static_assert( sizeof( AttachmentDescriptionStencilLayoutKHR ) == sizeof( VkAttachmentDescriptionStencilLayoutKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentDescriptionStencilLayoutKHR>::value, "struct wrapper is not a standard layout!" );
@@ -21266,12 +21300,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkAttachmentReference*>(this) = rhs;
+      *this = rhs;
     }
 
     AttachmentReference& operator=( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkAttachmentReference*>(this) = rhs;
+      *this = *reinterpret_cast<vk::AttachmentReference const *>(&rhs);
       return *this;
     }
 
@@ -21315,55 +21349,30 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct AttachmentReference2KHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR AttachmentReference2KHR( uint32_t attachment_ = 0,
-                                                    vk::ImageLayout layout_ = vk::ImageLayout::eUndefined,
-                                                    vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() ) VULKAN_HPP_NOEXCEPT
-        : attachment( attachment_ )
-        , layout( layout_ )
-        , aspectMask( aspectMask_ )
-      {}
-
-      AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAttachmentReference2KHR*>(this) = rhs;
-      }
-
-      AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct AttachmentReference2KHR
   {
     VULKAN_HPP_CONSTEXPR AttachmentReference2KHR( uint32_t attachment_ = 0,
                                                   vk::ImageLayout layout_ = vk::ImageLayout::eUndefined,
                                                   vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::AttachmentReference2KHR( attachment_, layout_, aspectMask_ )
+      : attachment( attachment_ )
+      , layout( layout_ )
+      , aspectMask( aspectMask_ )
     {}
 
+    vk::AttachmentReference2KHR & operator=( vk::AttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentReference2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AttachmentReference2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AttachmentReference2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::AttachmentReference2KHR const *>(&rhs);
       return *this;
     }
 
@@ -21415,53 +21424,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AttachmentReference2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eAttachmentReference2KHR;
+    const void* pNext = nullptr;
+    uint32_t attachment;
+    vk::ImageLayout layout;
+    vk::ImageAspectFlags aspectMask;
   };
   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!" );
 
-  namespace layout
-  {
-    struct AttachmentReferenceStencilLayoutKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayoutKHR( vk::ImageLayout stencilLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
-        : stencilLayout( stencilLayout_ )
-      {}
-
-      AttachmentReferenceStencilLayoutKHR( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAttachmentReferenceStencilLayoutKHR*>(this) = rhs;
-      }
-
-      AttachmentReferenceStencilLayoutKHR& operator=( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkAttachmentReferenceStencilLayoutKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::eAttachmentReferenceStencilLayoutKHR;
-      void* pNext = nullptr;
-      vk::ImageLayout stencilLayout;
-    };
-    static_assert( sizeof( AttachmentReferenceStencilLayoutKHR ) == sizeof( VkAttachmentReferenceStencilLayoutKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct AttachmentReferenceStencilLayoutKHR : public layout::AttachmentReferenceStencilLayoutKHR
+  struct AttachmentReferenceStencilLayoutKHR
   {
     VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayoutKHR( vk::ImageLayout stencilLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
-      : layout::AttachmentReferenceStencilLayoutKHR( stencilLayout_ )
+      : stencilLayout( stencilLayout_ )
     {}
 
+    vk::AttachmentReferenceStencilLayoutKHR & operator=( vk::AttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentReferenceStencilLayoutKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     AttachmentReferenceStencilLayoutKHR( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::AttachmentReferenceStencilLayoutKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     AttachmentReferenceStencilLayoutKHR& operator=( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::AttachmentReferenceStencilLayoutKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::AttachmentReferenceStencilLayoutKHR const *>(&rhs);
       return *this;
     }
 
@@ -21499,8 +21491,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::AttachmentReferenceStencilLayoutKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eAttachmentReferenceStencilLayoutKHR;
+    void* pNext = nullptr;
+    vk::ImageLayout stencilLayout;
   };
   static_assert( sizeof( AttachmentReferenceStencilLayoutKHR ) == sizeof( VkAttachmentReferenceStencilLayoutKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<AttachmentReferenceStencilLayoutKHR>::value, "struct wrapper is not a standard layout!" );
@@ -21515,12 +21509,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExtent2D*>(this) = rhs;
+      *this = rhs;
     }
 
     Extent2D& operator=( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExtent2D*>(this) = rhs;
+      *this = *reinterpret_cast<vk::Extent2D const *>(&rhs);
       return *this;
     }
 
@@ -21574,12 +21568,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSampleLocationEXT*>(this) = rhs;
+      *this = rhs;
     }
 
     SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSampleLocationEXT*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SampleLocationEXT const *>(&rhs);
       return *this;
     }
 
@@ -21623,59 +21617,32 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct SampleLocationsInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1,
-                                                   vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(),
-                                                   uint32_t sampleLocationsCount_ = 0,
-                                                   const vk::SampleLocationEXT* pSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
-        , sampleLocationGridSize( sampleLocationGridSize_ )
-        , sampleLocationsCount( sampleLocationsCount_ )
-        , pSampleLocations( pSampleLocations_ )
-      {}
-
-      SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSampleLocationsInfoEXT*>(this) = rhs;
-      }
-
-      SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SampleLocationsInfoEXT
   {
     VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1,
                                                  vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(),
                                                  uint32_t sampleLocationsCount_ = 0,
                                                  const vk::SampleLocationEXT* pSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::SampleLocationsInfoEXT( sampleLocationsPerPixel_, sampleLocationGridSize_, sampleLocationsCount_, pSampleLocations_ )
+      : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
+      , sampleLocationGridSize( sampleLocationGridSize_ )
+      , sampleLocationsCount( sampleLocationsCount_ )
+      , pSampleLocations( pSampleLocations_ )
     {}
 
+    vk::SampleLocationsInfoEXT & operator=( vk::SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SampleLocationsInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SampleLocationsInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SampleLocationsInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::SampleLocationsInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -21734,8 +21701,13 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SampleLocationsInfoEXT::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SampleLocationsInfoEXT>::value, "struct wrapper is not a standard layout!" );
@@ -21750,12 +21722,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this) = rhs;
+      *this = rhs;
     }
 
     AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this) = rhs;
+      *this = *reinterpret_cast<vk::AttachmentSampleLocationsEXT const *>(&rhs);
       return *this;
     }
 
@@ -21799,45 +21771,19 @@ namespace VULKAN_HPP_NAMESPACE
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBaseInStructure*>(this) = rhs;
-      }
-
-      BaseInStructure& operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BaseInStructure
   {
     BaseInStructure() VULKAN_HPP_NOEXCEPT
-      : layout::BaseInStructure()
     {}
 
     BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BaseInStructure( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BaseInStructure& operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BaseInStructure::operator=(rhs);
+      *this = *reinterpret_cast<vk::BaseInStructure const *>(&rhs);
       return *this;
     }
 
@@ -21868,51 +21814,26 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BaseInStructure::sType;
+  public:
+    vk::StructureType sType;
+    const struct vk::BaseInStructure* pNext = nullptr;
   };
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBaseOutStructure*>(this) = rhs;
-      }
-
-      BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BaseOutStructure
   {
     BaseOutStructure() VULKAN_HPP_NOEXCEPT
-      : layout::BaseOutStructure()
     {}
 
     BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BaseOutStructure( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BaseOutStructure::operator=(rhs);
+      *this = *reinterpret_cast<vk::BaseOutStructure const *>(&rhs);
       return *this;
     }
 
@@ -21943,69 +21864,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BaseOutStructure::sType;
+  public:
+    vk::StructureType sType;
+    struct vk::BaseOutStructure* pNext = nullptr;
   };
   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!" );
 
-  namespace layout
-  {
-    struct BindAccelerationStructureMemoryInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(),
-                                                                  vk::DeviceMemory memory_ = vk::DeviceMemory(),
-                                                                  vk::DeviceSize memoryOffset_ = 0,
-                                                                  uint32_t deviceIndexCount_ = 0,
-                                                                  const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : accelerationStructure( accelerationStructure_ )
-        , memory( memory_ )
-        , memoryOffset( memoryOffset_ )
-        , deviceIndexCount( deviceIndexCount_ )
-        , pDeviceIndices( pDeviceIndices_ )
-      {}
-
-      BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this) = rhs;
-      }
-
-      BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BindAccelerationStructureMemoryInfoNV
   {
     VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(),
                                                                 vk::DeviceMemory memory_ = vk::DeviceMemory(),
                                                                 vk::DeviceSize memoryOffset_ = 0,
                                                                 uint32_t deviceIndexCount_ = 0,
                                                                 const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::BindAccelerationStructureMemoryInfoNV( accelerationStructure_, memory_, memoryOffset_, deviceIndexCount_, pDeviceIndices_ )
+      : accelerationStructure( accelerationStructure_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
+      , deviceIndexCount( deviceIndexCount_ )
+      , pDeviceIndices( pDeviceIndices_ )
     {}
 
+    vk::BindAccelerationStructureMemoryInfoNV & operator=( vk::BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BindAccelerationStructureMemoryInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BindAccelerationStructureMemoryInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BindAccelerationStructureMemoryInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::BindAccelerationStructureMemoryInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -22071,57 +21964,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BindAccelerationStructureMemoryInfoNV::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
-                                                            const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : deviceIndexCount( deviceIndexCount_ )
-        , pDeviceIndices( pDeviceIndices_ )
-      {}
-
-      BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this) = rhs;
-      }
-
-      BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct BindBufferMemoryDeviceGroupInfo
   {
     VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
                                                           const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::BindBufferMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_ )
+      : deviceIndexCount( deviceIndexCount_ )
+      , pDeviceIndices( pDeviceIndices_ )
     {}
 
+    vk::BindBufferMemoryDeviceGroupInfo & operator=( vk::BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BindBufferMemoryDeviceGroupInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BindBufferMemoryDeviceGroupInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BindBufferMemoryDeviceGroupInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::BindBufferMemoryDeviceGroupInfo const *>(&rhs);
       return *this;
     }
 
@@ -22166,61 +22042,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BindBufferMemoryDeviceGroupInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo;
+    const void* pNext = nullptr;
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices;
   };
   static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindBufferMemoryDeviceGroupInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct BindBufferMemoryInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(),
-                                                 vk::DeviceMemory memory_ = vk::DeviceMemory(),
-                                                 vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : buffer( buffer_ )
-        , memory( memory_ )
-        , memoryOffset( memoryOffset_ )
-      {}
-
-      BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindBufferMemoryInfo*>(this) = rhs;
-      }
-
-      BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BindBufferMemoryInfo
   {
     VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(),
                                                vk::DeviceMemory memory_ = vk::DeviceMemory(),
                                                vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::BindBufferMemoryInfo( buffer_, memory_, memoryOffset_ )
+      : buffer( buffer_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
     {}
 
+    vk::BindBufferMemoryInfo & operator=( vk::BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BindBufferMemoryInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BindBufferMemoryInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BindBufferMemoryInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::BindBufferMemoryInfo const *>(&rhs);
       return *this;
     }
 
@@ -22272,8 +22126,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BindBufferMemoryInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eBindBufferMemoryInfo;
+    const void* pNext = nullptr;
+    vk::Buffer buffer;
+    vk::DeviceMemory memory;
+    vk::DeviceSize memoryOffset;
   };
   static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindBufferMemoryInfo>::value, "struct wrapper is not a standard layout!" );
@@ -22288,12 +22146,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkOffset2D*>(this) = rhs;
+      *this = rhs;
     }
 
     Offset2D& operator=( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkOffset2D*>(this) = rhs;
+      *this = *reinterpret_cast<vk::Offset2D const *>(&rhs);
       return *this;
     }
 
@@ -22347,12 +22205,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkRect2D*>(this) = rhs;
+      *this = rhs;
     }
 
     Rect2D& operator=( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkRect2D*>(this) = rhs;
+      *this = *reinterpret_cast<vk::Rect2D const *>(&rhs);
       return *this;
     }
 
@@ -22396,59 +22254,32 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct BindImageMemoryDeviceGroupInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
-                                                           const uint32_t* pDeviceIndices_ = nullptr,
-                                                           uint32_t splitInstanceBindRegionCount_ = 0,
-                                                           const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : deviceIndexCount( deviceIndexCount_ )
-        , pDeviceIndices( pDeviceIndices_ )
-        , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
-        , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
-      {}
-
-      BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this) = rhs;
-      }
-
-      BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BindImageMemoryDeviceGroupInfo
   {
     VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
                                                          const uint32_t* pDeviceIndices_ = nullptr,
                                                          uint32_t splitInstanceBindRegionCount_ = 0,
                                                          const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::BindImageMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_, splitInstanceBindRegionCount_, pSplitInstanceBindRegions_ )
+      : deviceIndexCount( deviceIndexCount_ )
+      , pDeviceIndices( pDeviceIndices_ )
+      , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
+      , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
     {}
 
+    vk::BindImageMemoryDeviceGroupInfo & operator=( vk::BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemoryDeviceGroupInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BindImageMemoryDeviceGroupInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BindImageMemoryDeviceGroupInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::BindImageMemoryDeviceGroupInfo const *>(&rhs);
       return *this;
     }
 
@@ -22507,61 +22338,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BindImageMemoryDeviceGroupInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( vk::Image image_ = vk::Image(),
-                                                vk::DeviceMemory memory_ = vk::DeviceMemory(),
-                                                vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : image( image_ )
-        , memory( memory_ )
-        , memoryOffset( memoryOffset_ )
-      {}
-
-      BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindImageMemoryInfo*>(this) = rhs;
-      }
-
-      BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::BindImageMemoryInfo
+  struct BindImageMemoryInfo
   {
     VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( vk::Image image_ = vk::Image(),
                                               vk::DeviceMemory memory_ = vk::DeviceMemory(),
                                               vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::BindImageMemoryInfo( image_, memory_, memoryOffset_ )
+      : image( image_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
     {}
 
+    vk::BindImageMemoryInfo & operator=( vk::BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemoryInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BindImageMemoryInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BindImageMemoryInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::BindImageMemoryInfo const *>(&rhs);
       return *this;
     }
 
@@ -22613,57 +22424,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BindImageMemoryInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eBindImageMemoryInfo;
+    const void* pNext = nullptr;
+    vk::Image image;
+    vk::DeviceMemory memory;
+    vk::DeviceSize memoryOffset;
   };
   static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindImageMemoryInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct BindImageMemorySwapchainInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
-                                                            uint32_t imageIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : swapchain( swapchain_ )
-        , imageIndex( imageIndex_ )
-      {}
-
-      BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this) = rhs;
-      }
-
-      BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BindImageMemorySwapchainInfoKHR
   {
     VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
                                                           uint32_t imageIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::BindImageMemorySwapchainInfoKHR( swapchain_, imageIndex_ )
+      : swapchain( swapchain_ )
+      , imageIndex( imageIndex_ )
     {}
 
+    vk::BindImageMemorySwapchainInfoKHR & operator=( vk::BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemorySwapchainInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BindImageMemorySwapchainInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BindImageMemorySwapchainInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::BindImageMemorySwapchainInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -22708,53 +22500,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BindImageMemorySwapchainInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR;
+    const void* pNext = nullptr;
+    vk::SwapchainKHR swapchain;
+    uint32_t imageIndex;
   };
   static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindImageMemorySwapchainInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct BindImagePlaneMemoryInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT
-        : planeAspect( planeAspect_ )
-      {}
-
-      BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this) = rhs;
-      }
-
-      BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct BindImagePlaneMemoryInfo
   {
     VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT
-      : layout::BindImagePlaneMemoryInfo( planeAspect_ )
+      : planeAspect( planeAspect_ )
     {}
 
+    vk::BindImagePlaneMemoryInfo & operator=( vk::BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImagePlaneMemoryInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BindImagePlaneMemoryInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BindImagePlaneMemoryInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::BindImagePlaneMemoryInfo const *>(&rhs);
       return *this;
     }
 
@@ -22792,8 +22566,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BindImagePlaneMemoryInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
+    const void* pNext = nullptr;
+    vk::ImageAspectFlagBits planeAspect;
   };
   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!" );
@@ -22814,12 +22590,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseMemoryBind*>(this) = rhs;
+      *this = rhs;
     }
 
     SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseMemoryBind*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SparseMemoryBind const *>(&rhs);
       return *this;
     }
 
@@ -22899,12 +22675,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this) = rhs;
+      *this = rhs;
     }
 
     SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SparseBufferMemoryBindInfo const *>(&rhs);
       return *this;
     }
 
@@ -22968,12 +22744,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this) = rhs;
+      *this = rhs;
     }
 
     SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SparseImageOpaqueMemoryBindInfo const *>(&rhs);
       return *this;
     }
 
@@ -23037,12 +22813,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageSubresource*>(this) = rhs;
+      *this = rhs;
     }
 
     ImageSubresource& operator=( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageSubresource*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ImageSubresource const *>(&rhs);
       return *this;
     }
 
@@ -23113,12 +22889,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkOffset3D*>(this) = rhs;
+      *this = rhs;
     }
 
     Offset3D& operator=( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkOffset3D*>(this) = rhs;
+      *this = *reinterpret_cast<vk::Offset3D const *>(&rhs);
       return *this;
     }
 
@@ -23189,12 +22965,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExtent3D*>(this) = rhs;
+      *this = rhs;
     }
 
     Extent3D& operator=( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExtent3D*>(this) = rhs;
+      *this = *reinterpret_cast<vk::Extent3D const *>(&rhs);
       return *this;
     }
 
@@ -23264,12 +23040,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageMemoryBind*>(this) = rhs;
+      *this = rhs;
     }
 
     SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageMemoryBind*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SparseImageMemoryBind const *>(&rhs);
       return *this;
     }
 
@@ -23357,12 +23133,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this) = rhs;
+      *this = rhs;
     }
 
     SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SparseImageMemoryBindInfo const *>(&rhs);
       return *this;
     }
 
@@ -23414,62 +23190,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : waitSemaphoreCount( waitSemaphoreCount_ )
-        , pWaitSemaphores( pWaitSemaphores_ )
-        , bufferBindCount( bufferBindCount_ )
-        , pBufferBinds( pBufferBinds_ )
-        , imageOpaqueBindCount( imageOpaqueBindCount_ )
-        , pImageOpaqueBinds( pImageOpaqueBinds_ )
-        , imageBindCount( imageBindCount_ )
-        , pImageBinds( pImageBinds_ )
-        , signalSemaphoreCount( signalSemaphoreCount_ )
-        , pSignalSemaphores( pSignalSemaphores_ )
-      {}
-
-      BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBindSparseInfo*>(this) = rhs;
-      }
-
-      BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BindSparseInfo
   {
     VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = 0,
                                          const vk::Semaphore* pWaitSemaphores_ = nullptr,
@@ -23481,16 +23202,32 @@ namespace VULKAN_HPP_NAMESPACE
                                          const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
                                          uint32_t signalSemaphoreCount_ = 0,
                                          const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::BindSparseInfo( waitSemaphoreCount_, pWaitSemaphores_, bufferBindCount_, pBufferBinds_, imageOpaqueBindCount_, pImageOpaqueBinds_, imageBindCount_, pImageBinds_, signalSemaphoreCount_, pSignalSemaphores_ )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphores( pWaitSemaphores_ )
+      , bufferBindCount( bufferBindCount_ )
+      , pBufferBinds( pBufferBinds_ )
+      , imageOpaqueBindCount( imageOpaqueBindCount_ )
+      , pImageOpaqueBinds( pImageOpaqueBinds_ )
+      , imageBindCount( imageBindCount_ )
+      , pImageBinds( pImageBinds_ )
+      , signalSemaphoreCount( signalSemaphoreCount_ )
+      , pSignalSemaphores( pSignalSemaphores_ )
     {}
 
+    vk::BindSparseInfo & operator=( vk::BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BindSparseInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BindSparseInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BindSparseInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::BindSparseInfo const *>(&rhs);
       return *this;
     }
 
@@ -23591,8 +23328,19 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BindSparseInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BindSparseInfo>::value, "struct wrapper is not a standard layout!" );
@@ -23609,12 +23357,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkBufferCopy*>(this) = rhs;
+      *this = rhs;
     }
 
     BufferCopy& operator=( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkBufferCopy*>(this) = rhs;
+      *this = *reinterpret_cast<vk::BufferCopy const *>(&rhs);
       return *this;
     }
 
@@ -23666,50 +23414,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , size( size_ )
-        , usage( usage_ )
-        , sharingMode( sharingMode_ )
-        , queueFamilyIndexCount( queueFamilyIndexCount_ )
-        , pQueueFamilyIndices( pQueueFamilyIndices_ )
-      {}
-
-      BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBufferCreateInfo*>(this) = rhs;
-      }
-
-      BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::BufferCreateInfo
+  struct BufferCreateInfo
   {
     VULKAN_HPP_CONSTEXPR BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
                                            vk::DeviceSize size_ = 0,
@@ -23717,16 +23422,28 @@ namespace VULKAN_HPP_NAMESPACE
                                            vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
                                            uint32_t queueFamilyIndexCount_ = 0,
                                            const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferCreateInfo( flags_, size_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ )
+      : flags( flags_ )
+      , size( size_ )
+      , usage( usage_ )
+      , sharingMode( sharingMode_ )
+      , queueFamilyIndexCount( queueFamilyIndexCount_ )
+      , pQueueFamilyIndices( pQueueFamilyIndices_ )
     {}
 
+    vk::BufferCreateInfo & operator=( vk::BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BufferCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::BufferCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -23799,53 +23516,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BufferCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : deviceAddress( deviceAddress_ )
-      {}
-
-      BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this) = rhs;
-      }
-
-      BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct BufferDeviceAddressCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferDeviceAddressCreateInfoEXT( deviceAddress_ )
+      : deviceAddress( deviceAddress_ )
     {}
 
+    vk::BufferDeviceAddressCreateInfoEXT & operator=( vk::BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferDeviceAddressCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferDeviceAddressCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BufferDeviceAddressCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::BufferDeviceAddressCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -23883,53 +23586,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BufferDeviceAddressCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::DeviceAddress deviceAddress;
   };
   static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferDeviceAddressCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct BufferDeviceAddressInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT
-        : buffer( buffer_ )
-      {}
-
-      BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBufferDeviceAddressInfoEXT*>(this) = rhs;
-      }
-
-      BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BufferDeviceAddressInfoEXT
   {
     VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferDeviceAddressInfoEXT( buffer_ )
+      : buffer( buffer_ )
     {}
 
+    vk::BufferDeviceAddressInfoEXT & operator=( vk::BufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferDeviceAddressInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferDeviceAddressInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BufferDeviceAddressInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::BufferDeviceAddressInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -23967,8 +23651,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BufferDeviceAddressInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eBufferDeviceAddressInfoEXT;
+    const void* pNext = nullptr;
+    vk::Buffer buffer;
   };
   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!" );
@@ -23987,12 +23673,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageSubresourceLayers*>(this) = rhs;
+      *this = rhs;
     }
 
     ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageSubresourceLayers*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ImageSubresourceLayers const *>(&rhs);
       return *this;
     }
 
@@ -24070,12 +23756,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkBufferImageCopy*>(this) = rhs;
+      *this = rhs;
     }
 
     BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkBufferImageCopy*>(this) = rhs;
+      *this = *reinterpret_cast<vk::BufferImageCopy const *>(&rhs);
       return *this;
     }
 
@@ -24151,53 +23837,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : srcAccessMask( srcAccessMask_ )
-        , dstAccessMask( dstAccessMask_ )
-        , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
-        , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
-        , buffer( buffer_ )
-        , offset( offset_ )
-        , size( size_ )
-      {}
-
-      BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBufferMemoryBarrier*>(this) = rhs;
-      }
-
-      BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BufferMemoryBarrier
   {
     VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
                                               vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
@@ -24206,16 +23846,29 @@ namespace VULKAN_HPP_NAMESPACE
                                               vk::Buffer buffer_ = vk::Buffer(),
                                               vk::DeviceSize offset_ = 0,
                                               vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferMemoryBarrier( srcAccessMask_, dstAccessMask_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, buffer_, offset_, size_ )
+      : srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
+      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+      , buffer( buffer_ )
+      , offset( offset_ )
+      , size( size_ )
     {}
 
+    vk::BufferMemoryBarrier & operator=( vk::BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferMemoryBarrier ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferMemoryBarrier( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BufferMemoryBarrier::operator=(rhs);
+      *this = *reinterpret_cast<vk::BufferMemoryBarrier const *>(&rhs);
       return *this;
     }
 
@@ -24295,53 +23948,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BufferMemoryBarrier::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT
-        : buffer( buffer_ )
-      {}
-
-      BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this) = rhs;
-      }
-
-      BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::BufferMemoryRequirementsInfo2
+  struct BufferMemoryRequirementsInfo2
   {
     VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferMemoryRequirementsInfo2( buffer_ )
+      : buffer( buffer_ )
     {}
 
+    vk::BufferMemoryRequirementsInfo2 & operator=( vk::BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferMemoryRequirementsInfo2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BufferMemoryRequirementsInfo2::operator=(rhs);
+      *this = *reinterpret_cast<vk::BufferMemoryRequirementsInfo2 const *>(&rhs);
       return *this;
     }
 
@@ -24379,69 +24019,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BufferMemoryRequirementsInfo2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2;
+    const void* pNext = nullptr;
+    vk::Buffer buffer;
   };
   static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<BufferMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct BufferViewCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , buffer( buffer_ )
-        , format( format_ )
-        , offset( offset_ )
-        , range( range_ )
-      {}
-
-      BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkBufferViewCreateInfo*>(this) = rhs;
-      }
-
-      BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct BufferViewCreateInfo
   {
     VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferViewCreateInfo( flags_, buffer_, format_, offset_, range_ )
+      : flags( flags_ )
+      , buffer( buffer_ )
+      , format( format_ )
+      , offset( offset_ )
+      , range( range_ )
     {}
 
+    vk::BufferViewCreateInfo & operator=( vk::BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferViewCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::BufferViewCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::BufferViewCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::BufferViewCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -24507,53 +24120,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::BufferViewCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT
-        : timeDomain( timeDomain_ )
-      {}
-
-      CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this) = rhs;
-      }
-
-      CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct CalibratedTimestampInfoEXT
   {
     VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT
-      : layout::CalibratedTimestampInfoEXT( timeDomain_ )
+      : timeDomain( timeDomain_ )
     {}
 
+    vk::CalibratedTimestampInfoEXT & operator=( vk::CalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CalibratedTimestampInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CalibratedTimestampInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CalibratedTimestampInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::CalibratedTimestampInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -24591,53 +24189,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CalibratedTimestampInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
+    const void* pNext = nullptr;
+    vk::TimeDomainEXT timeDomain;
   };
   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!" );
 
-  namespace layout
+  struct CheckpointDataNV
   {
-    struct CheckpointDataNV
-    {
-    protected:
-      CheckpointDataNV() VULKAN_HPP_NOEXCEPT
-      {}
-
-      CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCheckpointDataNV*>(this) = rhs;
-      }
-
-      CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    CheckpointDataNV() VULKAN_HPP_NOEXCEPT
-      : layout::CheckpointDataNV()
+    CheckpointDataNV( vk::PipelineStageFlagBits stage_ = vk::PipelineStageFlagBits::eTopOfPipe,
+                      void* pCheckpointMarker_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : stage( stage_ )
+      , pCheckpointMarker( pCheckpointMarker_ )
     {}
 
+    vk::CheckpointDataNV & operator=( vk::CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CheckpointDataNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CheckpointDataNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CheckpointDataNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::CheckpointDataNV const *>(&rhs);
       return *this;
     }
 
@@ -24664,8 +24245,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CheckpointDataNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eCheckpointDataNV;
+    void* pNext = nullptr;
+    vk::PipelineStageFlagBits stage;
+    void* pCheckpointMarker;
   };
   static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CheckpointDataNV>::value, "struct wrapper is not a standard layout!" );
@@ -24729,12 +24313,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkClearDepthStencilValue*>(this) = rhs;
+      *this = rhs;
     }
 
     ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkClearDepthStencilValue*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ClearDepthStencilValue const *>(&rhs);
       return *this;
     }
 
@@ -24832,12 +24416,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkClearAttachment*>(this) = rhs;
+      *this = rhs;
     }
 
     ClearAttachment& operator=( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkClearAttachment*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ClearAttachment const *>(&rhs);
       return *this;
     }
 
@@ -24889,12 +24473,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkClearRect*>(this) = rhs;
+      *this = rhs;
     }
 
     ClearRect& operator=( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkClearRect*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ClearRect const *>(&rhs);
       return *this;
     }
 
@@ -24958,12 +24542,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this) = rhs;
+      *this = rhs;
     }
 
     IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this) = rhs;
+      *this = *reinterpret_cast<vk::IndirectCommandsTokenNVX const *>(&rhs);
       return *this;
     }
 
@@ -25015,62 +24599,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : objectTable( objectTable_ )
-        , indirectCommandsLayout( indirectCommandsLayout_ )
-        , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
-        , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
-        , maxSequencesCount( maxSequencesCount_ )
-        , targetCommandBuffer( targetCommandBuffer_ )
-        , sequencesCountBuffer( sequencesCountBuffer_ )
-        , sequencesCountOffset( sequencesCountOffset_ )
-        , sequencesIndexBuffer( sequencesIndexBuffer_ )
-        , sequencesIndexOffset( sequencesIndexOffset_ )
-      {}
-
-      CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this) = rhs;
-      }
-
-      CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::CmdProcessCommandsInfoNVX
+  struct CmdProcessCommandsInfoNVX
   {
     VULKAN_HPP_CONSTEXPR CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
                                                     vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
@@ -25082,16 +24611,32 @@ namespace VULKAN_HPP_NAMESPACE
                                                     vk::DeviceSize sequencesCountOffset_ = 0,
                                                     vk::Buffer sequencesIndexBuffer_ = vk::Buffer(),
                                                     vk::DeviceSize sequencesIndexOffset_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::CmdProcessCommandsInfoNVX( objectTable_, indirectCommandsLayout_, indirectCommandsTokenCount_, pIndirectCommandsTokens_, maxSequencesCount_, targetCommandBuffer_, sequencesCountBuffer_, sequencesCountOffset_, sequencesIndexBuffer_, sequencesIndexOffset_ )
+      : objectTable( objectTable_ )
+      , indirectCommandsLayout( indirectCommandsLayout_ )
+      , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
+      , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
+      , maxSequencesCount( maxSequencesCount_ )
+      , targetCommandBuffer( targetCommandBuffer_ )
+      , sequencesCountBuffer( sequencesCountBuffer_ )
+      , sequencesCountOffset( sequencesCountOffset_ )
+      , sequencesIndexBuffer( sequencesIndexBuffer_ )
+      , sequencesIndexOffset( sequencesIndexOffset_ )
     {}
 
+    vk::CmdProcessCommandsInfoNVX & operator=( vk::CmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CmdProcessCommandsInfoNVX ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CmdProcessCommandsInfoNVX( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CmdProcessCommandsInfoNVX::operator=(rhs);
+      *this = *reinterpret_cast<vk::CmdProcessCommandsInfoNVX const *>(&rhs);
       return *this;
     }
 
@@ -25192,61 +24737,47 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CmdProcessCommandsInfoNVX::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
-                                                              vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
-                                                              uint32_t maxSequencesCount_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : objectTable( objectTable_ )
-        , indirectCommandsLayout( indirectCommandsLayout_ )
-        , maxSequencesCount( maxSequencesCount_ )
-      {}
-
-      CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this) = rhs;
-      }
-
-      CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::CmdReserveSpaceForCommandsInfoNVX
+  struct CmdReserveSpaceForCommandsInfoNVX
   {
     VULKAN_HPP_CONSTEXPR CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
                                                             vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
                                                             uint32_t maxSequencesCount_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::CmdReserveSpaceForCommandsInfoNVX( objectTable_, indirectCommandsLayout_, maxSequencesCount_ )
+      : objectTable( objectTable_ )
+      , indirectCommandsLayout( indirectCommandsLayout_ )
+      , maxSequencesCount( maxSequencesCount_ )
     {}
 
+    vk::CmdReserveSpaceForCommandsInfoNVX & operator=( vk::CmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CmdReserveSpaceForCommandsInfoNVX ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CmdReserveSpaceForCommandsInfoNVX( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CmdReserveSpaceForCommandsInfoNVX::operator=(rhs);
+      *this = *reinterpret_cast<vk::CmdReserveSpaceForCommandsInfoNVX const *>(&rhs);
       return *this;
     }
 
@@ -25298,8 +24829,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CmdReserveSpaceForCommandsInfoNVX::sType;
+  public:
+    const vk::StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
+    const void* pNext = nullptr;
+    vk::ObjectTableNVX objectTable;
+    vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
+    uint32_t maxSequencesCount;
   };
   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!" );
@@ -25316,12 +24851,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkCoarseSampleLocationNV*>(this) = rhs;
+      *this = rhs;
     }
 
     CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkCoarseSampleLocationNV*>(this) = rhs;
+      *this = *reinterpret_cast<vk::CoarseSampleLocationNV const *>(&rhs);
       return *this;
     }
 
@@ -25387,12 +24922,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this) = rhs;
+      *this = rhs;
     }
 
     CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this) = rhs;
+      *this = *reinterpret_cast<vk::CoarseSampleOrderCustomNV const *>(&rhs);
       return *this;
     }
 
@@ -25452,55 +24987,30 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct CommandBufferAllocateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(),
-                                                      vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary,
-                                                      uint32_t commandBufferCount_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : commandPool( commandPool_ )
-        , level( level_ )
-        , commandBufferCount( commandBufferCount_ )
-      {}
-
-      CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCommandBufferAllocateInfo*>(this) = rhs;
-      }
-
-      CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct CommandBufferAllocateInfo
   {
     VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(),
                                                     vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary,
                                                     uint32_t commandBufferCount_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandBufferAllocateInfo( commandPool_, level_, commandBufferCount_ )
+      : commandPool( commandPool_ )
+      , level( level_ )
+      , commandBufferCount( commandBufferCount_ )
     {}
 
+    vk::CommandBufferAllocateInfo & operator=( vk::CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferAllocateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandBufferAllocateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CommandBufferAllocateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::CommandBufferAllocateInfo const *>(&rhs);
       return *this;
     }
 
@@ -25552,56 +25062,17 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CommandBufferAllocateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eCommandBufferAllocateInfo;
+    const void* pNext = nullptr;
+    vk::CommandPool commandPool;
+    vk::CommandBufferLevel level;
+    uint32_t commandBufferCount;
   };
   static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct CommandBufferInheritanceInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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() ) VULKAN_HPP_NOEXCEPT
-        : renderPass( renderPass_ )
-        , subpass( subpass_ )
-        , framebuffer( framebuffer_ )
-        , occlusionQueryEnable( occlusionQueryEnable_ )
-        , queryFlags( queryFlags_ )
-        , pipelineStatistics( pipelineStatistics_ )
-      {}
-
-      CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this) = rhs;
-      }
-
-      CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct CommandBufferInheritanceInfo
   {
     VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
                                                        uint32_t subpass_ = 0,
@@ -25609,16 +25080,28 @@ namespace VULKAN_HPP_NAMESPACE
                                                        vk::Bool32 occlusionQueryEnable_ = 0,
                                                        vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(),
                                                        vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandBufferInheritanceInfo( renderPass_, subpass_, framebuffer_, occlusionQueryEnable_, queryFlags_, pipelineStatistics_ )
+      : renderPass( renderPass_ )
+      , subpass( subpass_ )
+      , framebuffer( framebuffer_ )
+      , occlusionQueryEnable( occlusionQueryEnable_ )
+      , queryFlags( queryFlags_ )
+      , pipelineStatistics( pipelineStatistics_ )
     {}
 
+    vk::CommandBufferInheritanceInfo & operator=( vk::CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferInheritanceInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandBufferInheritanceInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CommandBufferInheritanceInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::CommandBufferInheritanceInfo const *>(&rhs);
       return *this;
     }
 
@@ -25691,57 +25174,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CommandBufferInheritanceInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferInheritanceInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct CommandBufferBeginInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(),
-                                                   const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , pInheritanceInfo( pInheritanceInfo_ )
-      {}
-
-      CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCommandBufferBeginInfo*>(this) = rhs;
-      }
-
-      CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct CommandBufferBeginInfo
   {
     VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(),
                                                  const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandBufferBeginInfo( flags_, pInheritanceInfo_ )
+      : flags( flags_ )
+      , pInheritanceInfo( pInheritanceInfo_ )
     {}
 
+    vk::CommandBufferBeginInfo & operator=( vk::CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferBeginInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandBufferBeginInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CommandBufferBeginInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::CommandBufferBeginInfo const *>(&rhs);
       return *this;
     }
 
@@ -25786,53 +25253,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CommandBufferBeginInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eCommandBufferBeginInfo;
+    const void* pNext = nullptr;
+    vk::CommandBufferUsageFlags flags;
+    const vk::CommandBufferInheritanceInfo* pInheritanceInfo;
   };
   static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferBeginInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct CommandBufferInheritanceConditionalRenderingInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : conditionalRenderingEnable( conditionalRenderingEnable_ )
-      {}
-
-      CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this) = rhs;
-      }
-
-      CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct CommandBufferInheritanceConditionalRenderingInfoEXT
   {
     VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( conditionalRenderingEnable_ )
+      : conditionalRenderingEnable( conditionalRenderingEnable_ )
     {}
 
+    vk::CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( vk::CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferInheritanceConditionalRenderingInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CommandBufferInheritanceConditionalRenderingInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::CommandBufferInheritanceConditionalRenderingInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -25870,57 +25319,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CommandBufferInheritanceConditionalRenderingInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
+    const void* pNext = nullptr;
+    vk::Bool32 conditionalRenderingEnable;
   };
   static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandBufferInheritanceConditionalRenderingInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct CommandPoolCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(),
-                                                  uint32_t queueFamilyIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , queueFamilyIndex( queueFamilyIndex_ )
-      {}
-
-      CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCommandPoolCreateInfo*>(this) = rhs;
-      }
-
-      CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct CommandPoolCreateInfo
   {
     VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(),
                                                 uint32_t queueFamilyIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandPoolCreateInfo( flags_, queueFamilyIndex_ )
+      : flags( flags_ )
+      , queueFamilyIndex( queueFamilyIndex_ )
     {}
 
+    vk::CommandPoolCreateInfo & operator=( vk::CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandPoolCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CommandPoolCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CommandPoolCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::CommandPoolCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -25965,8 +25393,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CommandPoolCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eCommandPoolCreateInfo;
+    const void* pNext = nullptr;
+    vk::CommandPoolCreateFlags flags;
+    uint32_t queueFamilyIndex;
   };
   static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<CommandPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
@@ -25983,12 +25414,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSpecializationMapEntry*>(this) = rhs;
+      *this = rhs;
     }
 
     SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSpecializationMapEntry*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SpecializationMapEntry const *>(&rhs);
       return *this;
     }
 
@@ -26054,12 +25485,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSpecializationInfo*>(this) = rhs;
+      *this = rhs;
     }
 
     SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSpecializationInfo*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SpecializationInfo const *>(&rhs);
       return *this;
     }
 
@@ -26119,63 +25550,34 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , stage( stage_ )
-        , module( module_ )
-        , pName( pName_ )
-        , pSpecializationInfo( pSpecializationInfo_ )
-      {}
-
-      PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this) = rhs;
-      }
-
-      PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineShaderStageCreateInfo
+  struct PipelineShaderStageCreateInfo
   {
     VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineShaderStageCreateInfo( flags_, stage_, module_, pName_, pSpecializationInfo_ )
+      : flags( flags_ )
+      , stage( stage_ )
+      , module( module_ )
+      , pName( pName_ )
+      , pSpecializationInfo( pSpecializationInfo_ )
     {}
 
+    vk::PipelineShaderStageCreateInfo & operator=( vk::PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineShaderStageCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineShaderStageCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineShaderStageCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineShaderStageCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -26241,69 +25643,46 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineShaderStageCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , stage( stage_ )
-        , layout( layout_ )
-        , basePipelineHandle( basePipelineHandle_ )
-        , basePipelineIndex( basePipelineIndex_ )
-      {}
-
-      ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkComputePipelineCreateInfo*>(this) = rhs;
-      }
-
-      ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ComputePipelineCreateInfo
   {
     VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-      : layout::ComputePipelineCreateInfo( flags_, stage_, layout_, basePipelineHandle_, basePipelineIndex_ )
+      : flags( flags_ )
+      , stage( stage_ )
+      , layout( layout_ )
+      , basePipelineHandle( basePipelineHandle_ )
+      , basePipelineIndex( basePipelineIndex_ )
     {}
 
+    vk::ComputePipelineCreateInfo & operator=( vk::ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ComputePipelineCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ComputePipelineCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ComputePipelineCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ComputePipelineCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -26369,61 +25748,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ComputePipelineCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ComputePipelineCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ConditionalRenderingBeginInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(),
-                                                             vk::DeviceSize offset_ = 0,
-                                                             vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() ) VULKAN_HPP_NOEXCEPT
-        : buffer( buffer_ )
-        , offset( offset_ )
-        , flags( flags_ )
-      {}
-
-      ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this) = rhs;
-      }
-
-      ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ConditionalRenderingBeginInfoEXT
   {
     VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(),
                                                            vk::DeviceSize offset_ = 0,
                                                            vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() ) VULKAN_HPP_NOEXCEPT
-      : layout::ConditionalRenderingBeginInfoEXT( buffer_, offset_, flags_ )
+      : buffer( buffer_ )
+      , offset( offset_ )
+      , flags( flags_ )
     {}
 
+    vk::ConditionalRenderingBeginInfoEXT & operator=( vk::ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ConditionalRenderingBeginInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ConditionalRenderingBeginInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ConditionalRenderingBeginInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ConditionalRenderingBeginInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -26475,8 +25835,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ConditionalRenderingBeginInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
+    const void* pNext = nullptr;
+    vk::Buffer buffer;
+    vk::DeviceSize offset;
+    vk::ConditionalRenderingFlagsEXT flags;
   };
   static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ConditionalRenderingBeginInfoEXT>::value, "struct wrapper is not a standard layout!" );
@@ -26495,12 +25859,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ConformanceVersionKHR( VkConformanceVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkConformanceVersionKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkConformanceVersionKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ConformanceVersionKHR const *>(&rhs);
       return *this;
     }
 
@@ -26560,56 +25924,7 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct CooperativeMatrixPropertiesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : MSize( MSize_ )
-        , NSize( NSize_ )
-        , KSize( KSize_ )
-        , AType( AType_ )
-        , BType( BType_ )
-        , CType( CType_ )
-        , DType( DType_ )
-        , scope( scope_ )
-      {}
-
-      CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(this) = rhs;
-      }
-
-      CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct CooperativeMatrixPropertiesNV
   {
     VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0,
                                                         uint32_t NSize_ = 0,
@@ -26619,16 +25934,30 @@ namespace VULKAN_HPP_NAMESPACE
                                                         vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16,
                                                         vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16,
                                                         vk::ScopeNV scope_ = vk::ScopeNV::eDevice ) VULKAN_HPP_NOEXCEPT
-      : layout::CooperativeMatrixPropertiesNV( MSize_, NSize_, KSize_, AType_, BType_, CType_, DType_, scope_ )
+      : MSize( MSize_ )
+      , NSize( NSize_ )
+      , KSize( KSize_ )
+      , AType( AType_ )
+      , BType( BType_ )
+      , CType( CType_ )
+      , DType( DType_ )
+      , scope( scope_ )
     {}
 
+    vk::CooperativeMatrixPropertiesNV & operator=( vk::CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CooperativeMatrixPropertiesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CooperativeMatrixPropertiesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CooperativeMatrixPropertiesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::CooperativeMatrixPropertiesNV const *>(&rhs);
       return *this;
     }
 
@@ -26715,59 +26044,22 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CooperativeMatrixPropertiesNV::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : srcSet( srcSet_ )
-        , srcBinding( srcBinding_ )
-        , srcArrayElement( srcArrayElement_ )
-        , dstSet( dstSet_ )
-        , dstBinding( dstBinding_ )
-        , dstArrayElement( dstArrayElement_ )
-        , descriptorCount( descriptorCount_ )
-      {}
-
-      CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkCopyDescriptorSet*>(this) = rhs;
-      }
-
-      CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::CopyDescriptorSet
+  struct CopyDescriptorSet
   {
     VULKAN_HPP_CONSTEXPR CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(),
                                             uint32_t srcBinding_ = 0,
@@ -26776,16 +26068,29 @@ namespace VULKAN_HPP_NAMESPACE
                                             uint32_t dstBinding_ = 0,
                                             uint32_t dstArrayElement_ = 0,
                                             uint32_t descriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::CopyDescriptorSet( srcSet_, srcBinding_, srcArrayElement_, dstSet_, dstBinding_, dstArrayElement_, descriptorCount_ )
+      : srcSet( srcSet_ )
+      , srcBinding( srcBinding_ )
+      , srcArrayElement( srcArrayElement_ )
+      , dstSet( dstSet_ )
+      , dstBinding( dstBinding_ )
+      , dstArrayElement( dstArrayElement_ )
+      , descriptorCount( descriptorCount_ )
     {}
 
+    vk::CopyDescriptorSet & operator=( vk::CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::CopyDescriptorSet ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::CopyDescriptorSet( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::CopyDescriptorSet::operator=(rhs);
+      *this = *reinterpret_cast<vk::CopyDescriptorSet const *>(&rhs);
       return *this;
     }
 
@@ -26865,67 +26170,48 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::CopyDescriptorSet::sType;
+  public:
+    const 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 ), "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
 
-  namespace layout
-  {
-    struct D3D12FenceSubmitInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
-                                                    const uint64_t* pWaitSemaphoreValues_ = nullptr,
-                                                    uint32_t signalSemaphoreValuesCount_ = 0,
-                                                    const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
-        , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
-        , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
-        , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
-      {}
-
-      D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this) = rhs;
-      }
-
-      D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct D3D12FenceSubmitInfoKHR
   {
     VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
                                                   const uint64_t* pWaitSemaphoreValues_ = nullptr,
                                                   uint32_t signalSemaphoreValuesCount_ = 0,
                                                   const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::D3D12FenceSubmitInfoKHR( waitSemaphoreValuesCount_, pWaitSemaphoreValues_, signalSemaphoreValuesCount_, pSignalSemaphoreValues_ )
+      : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
+      , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
+      , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
+      , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
     {}
 
+    vk::D3D12FenceSubmitInfoKHR & operator=( vk::D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::D3D12FenceSubmitInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::D3D12FenceSubmitInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::D3D12FenceSubmitInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::D3D12FenceSubmitInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -26984,60 +26270,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::D3D12FenceSubmitInfoKHR::sType;
+  public:
+    const 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 ), "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*/
 
-  namespace layout
-  {
-    struct DebugMarkerMarkerInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
-                                                        std::array<float,4> const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
-        : pMarkerName( pMarkerName_ )
-        , color{}
-      {
-        vk::ConstExpressionArrayCopy<float,4,4>::copy( color, color_ );
-      }
-
-      DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this) = rhs;
-      }
-
-      DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DebugMarkerMarkerInfoEXT
   {
     VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
                                                       std::array<float,4> const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugMarkerMarkerInfoEXT( pMarkerName_, color_ )
-    {}
+      : pMarkerName( pMarkerName_ )
+      , color{}
+    {
+      vk::ConstExpressionArrayCopy<float,4,4>::copy( color, color_ );
+    }
+
+    vk::DebugMarkerMarkerInfoEXT & operator=( vk::DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerMarkerInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugMarkerMarkerInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugMarkerMarkerInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugMarkerMarkerInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -27082,61 +26350,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugMarkerMarkerInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
+    const void* pNext = nullptr;
+    const char* pMarkerName;
+    float color[4];
   };
   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:
-      VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
-                                                         uint64_t object_ = 0,
-                                                         const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : objectType( objectType_ )
-        , object( object_ )
-        , pObjectName( pObjectName_ )
-      {}
-
-      DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this) = rhs;
-      }
-
-      DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct DebugMarkerObjectNameInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
                                                        uint64_t object_ = 0,
                                                        const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugMarkerObjectNameInfoEXT( objectType_, object_, pObjectName_ )
+      : objectType( objectType_ )
+      , object( object_ )
+      , pObjectName( pObjectName_ )
     {}
 
+    vk::DebugMarkerObjectNameInfoEXT & operator=( vk::DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerObjectNameInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugMarkerObjectNameInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugMarkerObjectNameInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugMarkerObjectNameInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -27188,69 +26434,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugMarkerObjectNameInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
+    const void* pNext = nullptr;
+    vk::DebugReportObjectTypeEXT objectType;
+    uint64_t object;
+    const char* pObjectName;
   };
   static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugMarkerObjectNameInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DebugMarkerObjectTagInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
-                                                        uint64_t object_ = 0,
-                                                        uint64_t tagName_ = 0,
-                                                        size_t tagSize_ = 0,
-                                                        const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : objectType( objectType_ )
-        , object( object_ )
-        , tagName( tagName_ )
-        , tagSize( tagSize_ )
-        , pTag( pTag_ )
-      {}
-
-      DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this) = rhs;
-      }
-
-      DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DebugMarkerObjectTagInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
                                                       uint64_t object_ = 0,
                                                       uint64_t tagName_ = 0,
                                                       size_t tagSize_ = 0,
                                                       const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugMarkerObjectTagInfoEXT( objectType_, object_, tagName_, tagSize_, pTag_ )
+      : objectType( objectType_ )
+      , object( object_ )
+      , tagName( tagName_ )
+      , tagSize( tagSize_ )
+      , pTag( pTag_ )
     {}
 
+    vk::DebugMarkerObjectTagInfoEXT & operator=( vk::DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerObjectTagInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugMarkerObjectTagInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugMarkerObjectTagInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugMarkerObjectTagInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -27316,61 +26537,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugMarkerObjectTagInfoEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(),
-                                                             PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
-                                                             void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , pfnCallback( pfnCallback_ )
-        , pUserData( pUserData_ )
-      {}
-
-      DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this) = rhs;
-      }
-
-      DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DebugReportCallbackCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(),
                                                            PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
                                                            void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugReportCallbackCreateInfoEXT( flags_, pfnCallback_, pUserData_ )
+      : flags( flags_ )
+      , pfnCallback( pfnCallback_ )
+      , pUserData( pUserData_ )
     {}
 
+    vk::DebugReportCallbackCreateInfoEXT & operator=( vk::DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugReportCallbackCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugReportCallbackCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugReportCallbackCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugReportCallbackCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -27422,59 +26624,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugReportCallbackCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::DebugReportFlagsEXT flags;
+    PFN_vkDebugReportCallbackEXT pfnCallback;
+    void* pUserData;
   };
   static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugReportCallbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DebugUtilsLabelEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
-                                                  std::array<float,4> const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
-        : pLabelName( pLabelName_ )
-        , color{}
-      {
-        vk::ConstExpressionArrayCopy<float,4,4>::copy( color, color_ );
-      }
-
-      DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugUtilsLabelEXT*>(this) = rhs;
-      }
-
-      DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DebugUtilsLabelEXT
+  struct DebugUtilsLabelEXT
   {
     VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
                                                 std::array<float,4> const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsLabelEXT( pLabelName_, color_ )
-    {}
+      : pLabelName( pLabelName_ )
+      , color{}
+    {
+      vk::ConstExpressionArrayCopy<float,4,4>::copy( color, color_ );
+    }
+
+    vk::DebugUtilsLabelEXT & operator=( vk::DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsLabelEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsLabelEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugUtilsLabelEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugUtilsLabelEXT const *>(&rhs);
       return *this;
     }
 
@@ -27519,61 +26702,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugUtilsLabelEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDebugUtilsLabelEXT;
+    const void* pNext = nullptr;
+    const char* pLabelName;
+    float color[4];
   };
   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:
-      VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
-                                                        uint64_t objectHandle_ = 0,
-                                                        const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : objectType( objectType_ )
-        , objectHandle( objectHandle_ )
-        , pObjectName( pObjectName_ )
-      {}
-
-      DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this) = rhs;
-      }
-
-      DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DebugUtilsObjectNameInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
                                                       uint64_t objectHandle_ = 0,
                                                       const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsObjectNameInfoEXT( objectType_, objectHandle_, pObjectName_ )
+      : objectType( objectType_ )
+      , objectHandle( objectHandle_ )
+      , pObjectName( pObjectName_ )
     {}
 
+    vk::DebugUtilsObjectNameInfoEXT & operator=( vk::DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsObjectNameInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsObjectNameInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugUtilsObjectNameInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugUtilsObjectNameInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -27625,68 +26786,17 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugUtilsObjectNameInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
+    const void* pNext = nullptr;
+    vk::ObjectType objectType;
+    uint64_t objectHandle;
+    const char* pObjectName;
   };
   static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DebugUtilsObjectNameInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DebugUtilsMessengerCallbackDataEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , pMessageIdName( pMessageIdName_ )
-        , messageIdNumber( messageIdNumber_ )
-        , pMessage( pMessage_ )
-        , queueLabelCount( queueLabelCount_ )
-        , pQueueLabels( pQueueLabels_ )
-        , cmdBufLabelCount( cmdBufLabelCount_ )
-        , pCmdBufLabels( pCmdBufLabels_ )
-        , objectCount( objectCount_ )
-        , pObjects( pObjects_ )
-      {}
-
-      DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this) = rhs;
-      }
-
-      DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DebugUtilsMessengerCallbackDataEXT
   {
     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(),
                                                              const char* pMessageIdName_ = nullptr,
@@ -27698,16 +26808,32 @@ namespace VULKAN_HPP_NAMESPACE
                                                              const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
                                                              uint32_t objectCount_ = 0,
                                                              const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsMessengerCallbackDataEXT( flags_, pMessageIdName_, messageIdNumber_, pMessage_, queueLabelCount_, pQueueLabels_, cmdBufLabelCount_, pCmdBufLabels_, objectCount_, pObjects_ )
+      : flags( flags_ )
+      , pMessageIdName( pMessageIdName_ )
+      , messageIdNumber( messageIdNumber_ )
+      , pMessage( pMessage_ )
+      , queueLabelCount( queueLabelCount_ )
+      , pQueueLabels( pQueueLabels_ )
+      , cmdBufLabelCount( cmdBufLabelCount_ )
+      , pCmdBufLabels( pCmdBufLabels_ )
+      , objectCount( objectCount_ )
+      , pObjects( pObjects_ )
     {}
 
+    vk::DebugUtilsMessengerCallbackDataEXT & operator=( vk::DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsMessengerCallbackDataEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsMessengerCallbackDataEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugUtilsMessengerCallbackDataEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugUtilsMessengerCallbackDataEXT const *>(&rhs);
       return *this;
     }
 
@@ -27808,69 +26934,51 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugUtilsMessengerCallbackDataEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(),
-                                                             vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(),
-                                                             vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(),
-                                                             PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
-                                                             void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , messageSeverity( messageSeverity_ )
-        , messageType( messageType_ )
-        , pfnUserCallback( pfnUserCallback_ )
-        , pUserData( pUserData_ )
-      {}
-
-      DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this) = rhs;
-      }
-
-      DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DebugUtilsMessengerCreateInfoEXT
+  struct DebugUtilsMessengerCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(),
                                                            vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(),
                                                            vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(),
                                                            PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
                                                            void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsMessengerCreateInfoEXT( flags_, messageSeverity_, messageType_, pfnUserCallback_, pUserData_ )
+      : flags( flags_ )
+      , messageSeverity( messageSeverity_ )
+      , messageType( messageType_ )
+      , pfnUserCallback( pfnUserCallback_ )
+      , pUserData( pUserData_ )
     {}
 
+    vk::DebugUtilsMessengerCreateInfoEXT & operator=( vk::DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsMessengerCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsMessengerCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugUtilsMessengerCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugUtilsMessengerCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -27936,69 +27044,46 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugUtilsMessengerCreateInfoEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
-                                                       uint64_t objectHandle_ = 0,
-                                                       uint64_t tagName_ = 0,
-                                                       size_t tagSize_ = 0,
-                                                       const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : objectType( objectType_ )
-        , objectHandle( objectHandle_ )
-        , tagName( tagName_ )
-        , tagSize( tagSize_ )
-        , pTag( pTag_ )
-      {}
-
-      DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this) = rhs;
-      }
-
-      DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct DebugUtilsObjectTagInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
                                                      uint64_t objectHandle_ = 0,
                                                      uint64_t tagName_ = 0,
                                                      size_t tagSize_ = 0,
                                                      const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsObjectTagInfoEXT( objectType_, objectHandle_, tagName_, tagSize_, pTag_ )
+      : objectType( objectType_ )
+      , objectHandle( objectHandle_ )
+      , tagName( tagName_ )
+      , tagSize( tagSize_ )
+      , pTag( pTag_ )
     {}
 
+    vk::DebugUtilsObjectTagInfoEXT & operator=( vk::DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsObjectTagInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DebugUtilsObjectTagInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DebugUtilsObjectTagInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DebugUtilsObjectTagInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -28064,53 +27149,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DebugUtilsObjectTagInfoEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : dedicatedAllocation( dedicatedAllocation_ )
-      {}
-
-      DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this) = rhs;
-      }
-
-      DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DedicatedAllocationBufferCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DedicatedAllocationBufferCreateInfoNV( dedicatedAllocation_ )
+      : dedicatedAllocation( dedicatedAllocation_ )
     {}
 
+    vk::DedicatedAllocationBufferCreateInfoNV & operator=( vk::DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationBufferCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DedicatedAllocationBufferCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DedicatedAllocationBufferCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::DedicatedAllocationBufferCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -28148,53 +27218,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DedicatedAllocationBufferCreateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
+    const void* pNext = nullptr;
+    vk::Bool32 dedicatedAllocation;
   };
   static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DedicatedAllocationBufferCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DedicatedAllocationImageCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : dedicatedAllocation( dedicatedAllocation_ )
-      {}
-
-      DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this) = rhs;
-      }
-
-      DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DedicatedAllocationImageCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DedicatedAllocationImageCreateInfoNV( dedicatedAllocation_ )
+      : dedicatedAllocation( dedicatedAllocation_ )
     {}
 
+    vk::DedicatedAllocationImageCreateInfoNV & operator=( vk::DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationImageCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DedicatedAllocationImageCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DedicatedAllocationImageCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::DedicatedAllocationImageCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -28232,57 +27283,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DedicatedAllocationImageCreateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
+    const void* pNext = nullptr;
+    vk::Bool32 dedicatedAllocation;
   };
   static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DedicatedAllocationImageCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DedicatedAllocationMemoryAllocateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(),
-                                                                    vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT
-        : image( image_ )
-        , buffer( buffer_ )
-      {}
-
-      DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this) = rhs;
-      }
-
-      DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DedicatedAllocationMemoryAllocateInfoNV
   {
     VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(),
                                                                   vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT
-      : layout::DedicatedAllocationMemoryAllocateInfoNV( image_, buffer_ )
+      : image( image_ )
+      , buffer( buffer_ )
     {}
 
+    vk::DedicatedAllocationMemoryAllocateInfoNV & operator=( vk::DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationMemoryAllocateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DedicatedAllocationMemoryAllocateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DedicatedAllocationMemoryAllocateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::DedicatedAllocationMemoryAllocateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -28327,8 +27357,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DedicatedAllocationMemoryAllocateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
+    const void* pNext = nullptr;
+    vk::Image image;
+    vk::Buffer buffer;
   };
   static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DedicatedAllocationMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" );
@@ -28345,12 +27378,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorBufferInfo*>(this) = rhs;
+      *this = rhs;
     }
 
     DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorBufferInfo*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DescriptorBufferInfo const *>(&rhs);
       return *this;
     }
 
@@ -28414,12 +27447,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorImageInfo*>(this) = rhs;
+      *this = rhs;
     }
 
     DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorImageInfo*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DescriptorImageInfo const *>(&rhs);
       return *this;
     }
 
@@ -28481,12 +27514,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorPoolSize*>(this) = rhs;
+      *this = rhs;
     }
 
     DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorPoolSize*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DescriptorPoolSize const *>(&rhs);
       return *this;
     }
 
@@ -28530,59 +27563,32 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(),
-                                                     uint32_t maxSets_ = 0,
-                                                     uint32_t poolSizeCount_ = 0,
-                                                     const vk::DescriptorPoolSize* pPoolSizes_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , maxSets( maxSets_ )
-        , poolSizeCount( poolSizeCount_ )
-        , pPoolSizes( pPoolSizes_ )
-      {}
-
-      DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this) = rhs;
-      }
-
-      DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DescriptorPoolCreateInfo
+  struct DescriptorPoolCreateInfo
   {
     VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(),
                                                    uint32_t maxSets_ = 0,
                                                    uint32_t poolSizeCount_ = 0,
                                                    const vk::DescriptorPoolSize* pPoolSizes_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorPoolCreateInfo( flags_, maxSets_, poolSizeCount_, pPoolSizes_ )
+      : flags( flags_ )
+      , maxSets( maxSets_ )
+      , poolSizeCount( poolSizeCount_ )
+      , pPoolSizes( pPoolSizes_ )
     {}
 
+    vk::DescriptorPoolCreateInfo & operator=( vk::DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorPoolCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorPoolCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorPoolCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorPoolCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -28641,53 +27647,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorPoolCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
-      {}
-
-      DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this) = rhs;
-      }
-
-      DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct DescriptorPoolInlineUniformBlockCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( maxInlineUniformBlockBindings_ )
+      : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
     {}
 
+    vk::DescriptorPoolInlineUniformBlockCreateInfoEXT & operator=( vk::DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorPoolInlineUniformBlockCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorPoolInlineUniformBlockCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -28725,61 +27715,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
+    const void* pNext = nullptr;
+    uint32_t maxInlineUniformBlockBindings;
   };
   static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorPoolInlineUniformBlockCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DescriptorSetAllocateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(),
-                                                      uint32_t descriptorSetCount_ = 0,
-                                                      const vk::DescriptorSetLayout* pSetLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : descriptorPool( descriptorPool_ )
-        , descriptorSetCount( descriptorSetCount_ )
-        , pSetLayouts( pSetLayouts_ )
-      {}
-
-      DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this) = rhs;
-      }
-
-      DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DescriptorSetAllocateInfo
+  struct DescriptorSetAllocateInfo
   {
     VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(),
                                                     uint32_t descriptorSetCount_ = 0,
                                                     const vk::DescriptorSetLayout* pSetLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetAllocateInfo( descriptorPool_, descriptorSetCount_, pSetLayouts_ )
+      : descriptorPool( descriptorPool_ )
+      , descriptorSetCount( descriptorSetCount_ )
+      , pSetLayouts( pSetLayouts_ )
     {}
 
+    vk::DescriptorSetAllocateInfo & operator=( vk::DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetAllocateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetAllocateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorSetAllocateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorSetAllocateInfo const *>(&rhs);
       return *this;
     }
 
@@ -28831,8 +27798,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorSetAllocateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetAllocateInfo>::value, "struct wrapper is not a standard layout!" );
@@ -28853,12 +27824,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this) = rhs;
+      *this = rhs;
     }
 
     DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DescriptorSetLayoutBinding const *>(&rhs);
       return *this;
     }
 
@@ -28926,51 +27897,28 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
-                                                                         const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : bindingCount( bindingCount_ )
-        , pBindingFlags( pBindingFlags_ )
-      {}
-
-      DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this) = rhs;
-      }
-
-      DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
                                                                        const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( bindingCount_, pBindingFlags_ )
+      : bindingCount( bindingCount_ )
+      , pBindingFlags( pBindingFlags_ )
     {}
 
+    vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT & operator=( vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -29015,61 +27963,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
+    const void* pNext = nullptr;
+    uint32_t bindingCount;
+    const vk::DescriptorBindingFlagsEXT* pBindingFlags;
   };
   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:
-      VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(),
-                                                          uint32_t bindingCount_ = 0,
-                                                          const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , bindingCount( bindingCount_ )
-        , pBindings( pBindings_ )
-      {}
-
-      DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this) = rhs;
-      }
-
-      DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DescriptorSetLayoutCreateInfo
   {
     VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(),
                                                         uint32_t bindingCount_ = 0,
                                                         const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetLayoutCreateInfo( flags_, bindingCount_, pBindings_ )
+      : flags( flags_ )
+      , bindingCount( bindingCount_ )
+      , pBindings( pBindings_ )
     {}
 
+    vk::DescriptorSetLayoutCreateInfo & operator=( vk::DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetLayoutCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorSetLayoutCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorSetLayoutCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -29121,52 +28047,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorSetLayoutCreateInfo::sType;
+  public:
+    const 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 ), "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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this) = rhs;
-      }
-
-      DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DescriptorSetLayoutSupport
   {
-    DescriptorSetLayoutSupport() VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetLayoutSupport()
+    DescriptorSetLayoutSupport( vk::Bool32 supported_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : supported( supported_ )
     {}
 
+    vk::DescriptorSetLayoutSupport & operator=( vk::DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutSupport ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetLayoutSupport( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorSetLayoutSupport::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorSetLayoutSupport const *>(&rhs);
       return *this;
     }
 
@@ -29192,57 +28102,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorSetLayoutSupport::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDescriptorSetLayoutSupport;
+    void* pNext = nullptr;
+    vk::Bool32 supported;
   };
   static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DescriptorSetLayoutSupport>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
-                                                                                const uint32_t* pDescriptorCounts_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : descriptorSetCount( descriptorSetCount_ )
-        , pDescriptorCounts( pDescriptorCounts_ )
-      {}
-
-      DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this) = rhs;
-      }
-
-      DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
                                                                               const uint32_t* pDescriptorCounts_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( descriptorSetCount_, pDescriptorCounts_ )
+      : descriptorSetCount( descriptorSetCount_ )
+      , pDescriptorCounts( pDescriptorCounts_ )
     {}
 
+    vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT & operator=( vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -29287,52 +28176,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT;
+    const void* pNext = nullptr;
+    uint32_t descriptorSetCount;
+    const uint32_t* pDescriptorCounts;
   };
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this) = rhs;
-      }
-
-      DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT
+  struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
   {
-    DescriptorSetVariableDescriptorCountLayoutSupportEXT() VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT()
+    DescriptorSetVariableDescriptorCountLayoutSupportEXT( uint32_t maxVariableDescriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxVariableDescriptorCount( maxVariableDescriptorCount_ )
     {}
 
+    vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT & operator=( vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT const *>(&rhs);
       return *this;
     }
 
@@ -29358,8 +28230,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT;
+    void* pNext = nullptr;
+    uint32_t maxVariableDescriptorCount;
   };
   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!" );
@@ -29382,12 +28256,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this) = rhs;
+      *this = rhs;
     }
 
     DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DescriptorUpdateTemplateEntry const *>(&rhs);
       return *this;
     }
 
@@ -29463,56 +28337,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
-        , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
-        , templateType( templateType_ )
-        , descriptorSetLayout( descriptorSetLayout_ )
-        , pipelineBindPoint( pipelineBindPoint_ )
-        , pipelineLayout( pipelineLayout_ )
-        , set( set_ )
-      {}
-
-      DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this) = rhs;
-      }
-
-      DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DescriptorUpdateTemplateCreateInfo
+  struct DescriptorUpdateTemplateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(),
                                                              uint32_t descriptorUpdateEntryCount_ = 0,
@@ -29522,16 +28347,30 @@ namespace VULKAN_HPP_NAMESPACE
                                                              vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
                                                              vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
                                                              uint32_t set_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorUpdateTemplateCreateInfo( flags_, descriptorUpdateEntryCount_, pDescriptorUpdateEntries_, templateType_, descriptorSetLayout_, pipelineBindPoint_, pipelineLayout_, set_ )
+      : flags( flags_ )
+      , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
+      , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
+      , templateType( templateType_ )
+      , descriptorSetLayout( descriptorSetLayout_ )
+      , pipelineBindPoint( pipelineBindPoint_ )
+      , pipelineLayout( pipelineLayout_ )
+      , set( set_ )
     {}
 
+    vk::DescriptorUpdateTemplateCreateInfo & operator=( vk::DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorUpdateTemplateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DescriptorUpdateTemplateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DescriptorUpdateTemplateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DescriptorUpdateTemplateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -29618,65 +28457,47 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DescriptorUpdateTemplateCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
-                                                  uint32_t queueFamilyIndex_ = 0,
-                                                  uint32_t queueCount_ = 0,
-                                                  const float* pQueuePriorities_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , queueFamilyIndex( queueFamilyIndex_ )
-        , queueCount( queueCount_ )
-        , pQueuePriorities( pQueuePriorities_ )
-      {}
-
-      DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceQueueCreateInfo*>(this) = rhs;
-      }
-
-      DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceQueueCreateInfo
   {
     VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
                                                 uint32_t queueFamilyIndex_ = 0,
                                                 uint32_t queueCount_ = 0,
                                                 const float* pQueuePriorities_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceQueueCreateInfo( flags_, queueFamilyIndex_, queueCount_, pQueuePriorities_ )
+      : flags( flags_ )
+      , queueFamilyIndex( queueFamilyIndex_ )
+      , queueCount( queueCount_ )
+      , pQueuePriorities( pQueuePriorities_ )
     {}
 
+    vk::DeviceQueueCreateInfo & operator=( vk::DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceQueueCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceQueueCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceQueueCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -29735,8 +28556,13 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceQueueCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceQueueCreateInfo>::value, "struct wrapper is not a standard layout!" );
@@ -29857,12 +28683,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceFeatures*>(this) = rhs;
+      *this = rhs;
     }
 
     PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceFeatures*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PhysicalDeviceFeatures const *>(&rhs);
       return *this;
     }
 
@@ -30330,56 +29156,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , queueCreateInfoCount( queueCreateInfoCount_ )
-        , pQueueCreateInfos( pQueueCreateInfos_ )
-        , enabledLayerCount( enabledLayerCount_ )
-        , ppEnabledLayerNames( ppEnabledLayerNames_ )
-        , enabledExtensionCount( enabledExtensionCount_ )
-        , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
-        , pEnabledFeatures( pEnabledFeatures_ )
-      {}
-
-      DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceCreateInfo*>(this) = rhs;
-      }
-
-      DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceCreateInfo
   {
     VULKAN_HPP_CONSTEXPR DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(),
                                            uint32_t queueCreateInfoCount_ = 0,
@@ -30389,16 +29166,30 @@ namespace VULKAN_HPP_NAMESPACE
                                            uint32_t enabledExtensionCount_ = 0,
                                            const char* const* ppEnabledExtensionNames_ = nullptr,
                                            const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceCreateInfo( flags_, queueCreateInfoCount_, pQueueCreateInfos_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_, pEnabledFeatures_ )
+      : flags( flags_ )
+      , queueCreateInfoCount( queueCreateInfoCount_ )
+      , pQueueCreateInfos( pQueueCreateInfos_ )
+      , enabledLayerCount( enabledLayerCount_ )
+      , ppEnabledLayerNames( ppEnabledLayerNames_ )
+      , enabledExtensionCount( enabledExtensionCount_ )
+      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+      , pEnabledFeatures( pEnabledFeatures_ )
     {}
 
+    vk::DeviceCreateInfo & operator=( vk::DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -30485,53 +29276,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT
-        : deviceEvent( deviceEvent_ )
-      {}
-
-      DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceEventInfoEXT*>(this) = rhs;
-      }
-
-      DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DeviceEventInfoEXT
+  struct DeviceEventInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceEventInfoEXT( deviceEvent_ )
+      : deviceEvent( deviceEvent_ )
     {}
 
+    vk::DeviceEventInfoEXT & operator=( vk::DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceEventInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceEventInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceEventInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceEventInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -30569,53 +29348,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceEventInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceEventInfoEXT;
+    const void* pNext = nullptr;
+    vk::DeviceEventTypeEXT deviceEvent;
   };
   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:
-      VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : computeBindingPointSupport( computeBindingPointSupport_ )
-      {}
-
-      DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this) = rhs;
-      }
-
-      DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceGeneratedCommandsFeaturesNVX
   {
     VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGeneratedCommandsFeaturesNVX( computeBindingPointSupport_ )
+      : computeBindingPointSupport( computeBindingPointSupport_ )
     {}
 
+    vk::DeviceGeneratedCommandsFeaturesNVX & operator=( vk::DeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGeneratedCommandsFeaturesNVX ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGeneratedCommandsFeaturesNVX( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGeneratedCommandsFeaturesNVX::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGeneratedCommandsFeaturesNVX const *>(&rhs);
       return *this;
     }
 
@@ -30653,69 +29413,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGeneratedCommandsFeaturesNVX::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
+    const void* pNext = nullptr;
+    vk::Bool32 computeBindingPointSupport;
   };
   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:
-      VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
-                                                             uint32_t maxObjectEntryCounts_ = 0,
-                                                             uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
-                                                             uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
-                                                             uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
-        , maxObjectEntryCounts( maxObjectEntryCounts_ )
-        , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
-        , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
-        , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
-      {}
-
-      DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this) = rhs;
-      }
-
-      DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceGeneratedCommandsLimitsNVX
   {
     VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
                                                            uint32_t maxObjectEntryCounts_ = 0,
                                                            uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
                                                            uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
                                                            uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGeneratedCommandsLimitsNVX( maxIndirectCommandsLayoutTokenCount_, maxObjectEntryCounts_, minSequenceCountBufferOffsetAlignment_, minSequenceIndexBufferOffsetAlignment_, minCommandsTokenBufferOffsetAlignment_ )
+      : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
+      , maxObjectEntryCounts( maxObjectEntryCounts_ )
+      , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
+      , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
+      , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
     {}
 
+    vk::DeviceGeneratedCommandsLimitsNVX & operator=( vk::DeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGeneratedCommandsLimitsNVX ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGeneratedCommandsLimitsNVX( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGeneratedCommandsLimitsNVX::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGeneratedCommandsLimitsNVX const *>(&rhs);
       return *this;
     }
 
@@ -30781,57 +29514,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGeneratedCommandsLimitsNVX::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGeneratedCommandsLimitsNVX>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DeviceGroupBindSparseInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
-                                                      uint32_t memoryDeviceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : resourceDeviceIndex( resourceDeviceIndex_ )
-        , memoryDeviceIndex( memoryDeviceIndex_ )
-      {}
-
-      DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this) = rhs;
-      }
-
-      DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceGroupBindSparseInfo
   {
     VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
                                                     uint32_t memoryDeviceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupBindSparseInfo( resourceDeviceIndex_, memoryDeviceIndex_ )
+      : resourceDeviceIndex( resourceDeviceIndex_ )
+      , memoryDeviceIndex( memoryDeviceIndex_ )
     {}
 
+    vk::DeviceGroupBindSparseInfo & operator=( vk::DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupBindSparseInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupBindSparseInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGroupBindSparseInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGroupBindSparseInfo const *>(&rhs);
       return *this;
     }
 
@@ -30876,53 +29592,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGroupBindSparseInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceGroupBindSparseInfo;
+    const void* pNext = nullptr;
+    uint32_t resourceDeviceIndex;
+    uint32_t memoryDeviceIndex;
   };
   static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupBindSparseInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DeviceGroupCommandBufferBeginInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : deviceMask( deviceMask_ )
-      {}
-
-      DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this) = rhs;
-      }
-
-      DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DeviceGroupCommandBufferBeginInfo
+  struct DeviceGroupCommandBufferBeginInfo
   {
     VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupCommandBufferBeginInfo( deviceMask_ )
+      : deviceMask( deviceMask_ )
     {}
 
+    vk::DeviceGroupCommandBufferBeginInfo & operator=( vk::DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupCommandBufferBeginInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupCommandBufferBeginInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGroupCommandBufferBeginInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGroupCommandBufferBeginInfo const *>(&rhs);
       return *this;
     }
 
@@ -30960,57 +29658,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGroupCommandBufferBeginInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo;
+    const void* pNext = nullptr;
+    uint32_t deviceMask;
   };
   static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupCommandBufferBeginInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DeviceGroupDeviceCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
-                                                        const vk::PhysicalDevice* pPhysicalDevices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : physicalDeviceCount( physicalDeviceCount_ )
-        , pPhysicalDevices( pPhysicalDevices_ )
-      {}
-
-      DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this) = rhs;
-      }
-
-      DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct DeviceGroupDeviceCreateInfo
   {
     VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
                                                       const vk::PhysicalDevice* pPhysicalDevices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupDeviceCreateInfo( physicalDeviceCount_, pPhysicalDevices_ )
+      : physicalDeviceCount( physicalDeviceCount_ )
+      , pPhysicalDevices( pPhysicalDevices_ )
     {}
 
+    vk::DeviceGroupDeviceCreateInfo & operator=( vk::DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupDeviceCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupDeviceCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGroupDeviceCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGroupDeviceCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -31055,53 +29732,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGroupDeviceCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo;
+    const void* pNext = nullptr;
+    uint32_t physicalDeviceCount;
+    const vk::PhysicalDevice* pPhysicalDevices;
   };
   static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupDeviceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct DeviceGroupPresentCapabilitiesKHR
   {
-    struct DeviceGroupPresentCapabilitiesKHR
+    DeviceGroupPresentCapabilitiesKHR( std::array<uint32_t,VK_MAX_DEVICE_GROUP_SIZE> const& presentMask_ = { { 0 } },
+                                       vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT
+      : presentMask{}
+      , modes( modes_ )
     {
-    protected:
-      DeviceGroupPresentCapabilitiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this) = rhs;
-      }
-
-      DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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!" );
-  }
+      vk::ConstExpressionArrayCopy<uint32_t,VK_MAX_DEVICE_GROUP_SIZE,VK_MAX_DEVICE_GROUP_SIZE>::copy( presentMask, presentMask_ );
+    }
 
-  struct DeviceGroupPresentCapabilitiesKHR : public layout::DeviceGroupPresentCapabilitiesKHR
-  {
-    DeviceGroupPresentCapabilitiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupPresentCapabilitiesKHR()
-    {}
+    vk::DeviceGroupPresentCapabilitiesKHR & operator=( vk::DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupPresentCapabilitiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupPresentCapabilitiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGroupPresentCapabilitiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGroupPresentCapabilitiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -31128,61 +29791,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGroupPresentCapabilitiesKHR::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
-                                                      const uint32_t* pDeviceMasks_ = nullptr,
-                                                      vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal ) VULKAN_HPP_NOEXCEPT
-        : swapchainCount( swapchainCount_ )
-        , pDeviceMasks( pDeviceMasks_ )
-        , mode( mode_ )
-      {}
-
-      DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this) = rhs;
-      }
-
-      DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceGroupPresentInfoKHR
   {
     VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
                                                     const uint32_t* pDeviceMasks_ = nullptr,
                                                     vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupPresentInfoKHR( swapchainCount_, pDeviceMasks_, mode_ )
+      : swapchainCount( swapchainCount_ )
+      , pDeviceMasks( pDeviceMasks_ )
+      , mode( mode_ )
     {}
 
+    vk::DeviceGroupPresentInfoKHR & operator=( vk::DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupPresentInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupPresentInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGroupPresentInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGroupPresentInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -31234,61 +29875,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGroupPresentInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupPresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DeviceGroupRenderPassBeginInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
-                                                           uint32_t deviceRenderAreaCount_ = 0,
-                                                           const vk::Rect2D* pDeviceRenderAreas_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : deviceMask( deviceMask_ )
-        , deviceRenderAreaCount( deviceRenderAreaCount_ )
-        , pDeviceRenderAreas( pDeviceRenderAreas_ )
-      {}
-
-      DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this) = rhs;
-      }
-
-      DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceGroupRenderPassBeginInfo
   {
     VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
                                                          uint32_t deviceRenderAreaCount_ = 0,
                                                          const vk::Rect2D* pDeviceRenderAreas_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupRenderPassBeginInfo( deviceMask_, deviceRenderAreaCount_, pDeviceRenderAreas_ )
+      : deviceMask( deviceMask_ )
+      , deviceRenderAreaCount( deviceRenderAreaCount_ )
+      , pDeviceRenderAreas( pDeviceRenderAreas_ )
     {}
 
+    vk::DeviceGroupRenderPassBeginInfo & operator=( vk::DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupRenderPassBeginInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupRenderPassBeginInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGroupRenderPassBeginInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGroupRenderPassBeginInfo const *>(&rhs);
       return *this;
     }
 
@@ -31340,56 +29960,17 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGroupRenderPassBeginInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : waitSemaphoreCount( waitSemaphoreCount_ )
-        , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
-        , commandBufferCount( commandBufferCount_ )
-        , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
-        , signalSemaphoreCount( signalSemaphoreCount_ )
-        , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
-      {}
-
-      DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this) = rhs;
-      }
-
-      DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DeviceGroupSubmitInfo
+  struct DeviceGroupSubmitInfo
   {
     VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
                                                 const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
@@ -31397,16 +29978,28 @@ namespace VULKAN_HPP_NAMESPACE
                                                 const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
                                                 uint32_t signalSemaphoreCount_ = 0,
                                                 const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupSubmitInfo( waitSemaphoreCount_, pWaitSemaphoreDeviceIndices_, commandBufferCount_, pCommandBufferDeviceMasks_, signalSemaphoreCount_, pSignalSemaphoreDeviceIndices_ )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
+      , commandBufferCount( commandBufferCount_ )
+      , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
+      , signalSemaphoreCount( signalSemaphoreCount_ )
+      , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
     {}
 
+    vk::DeviceGroupSubmitInfo & operator=( vk::DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupSubmitInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupSubmitInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGroupSubmitInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGroupSubmitInfo const *>(&rhs);
       return *this;
     }
 
@@ -31479,53 +30072,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGroupSubmitInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT
-        : modes( modes_ )
-      {}
-
-      DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this) = rhs;
-      }
-
-      DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceGroupSwapchainCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupSwapchainCreateInfoKHR( modes_ )
+      : modes( modes_ )
     {}
 
+    vk::DeviceGroupSwapchainCreateInfoKHR & operator=( vk::DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupSwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceGroupSwapchainCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceGroupSwapchainCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceGroupSwapchainCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -31563,53 +30142,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceGroupSwapchainCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
+    const void* pNext = nullptr;
+    vk::DeviceGroupPresentModeFlagsKHR modes;
   };
   static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceGroupSwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DeviceMemoryOverallocationCreateInfoAMD
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT
-        : overallocationBehavior( overallocationBehavior_ )
-      {}
-
-      DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this) = rhs;
-      }
-
-      DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceMemoryOverallocationCreateInfoAMD
   {
     VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceMemoryOverallocationCreateInfoAMD( overallocationBehavior_ )
+      : overallocationBehavior( overallocationBehavior_ )
     {}
 
+    vk::DeviceMemoryOverallocationCreateInfoAMD & operator=( vk::DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceMemoryOverallocationCreateInfoAMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceMemoryOverallocationCreateInfoAMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceMemoryOverallocationCreateInfoAMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceMemoryOverallocationCreateInfoAMD const *>(&rhs);
       return *this;
     }
 
@@ -31647,53 +30207,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceMemoryOverallocationCreateInfoAMD::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
+    const void* pNext = nullptr;
+    vk::MemoryOverallocationBehaviorAMD overallocationBehavior;
   };
   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!" );
 
-  namespace layout
-  {
-    struct DeviceQueueGlobalPriorityCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT
-        : globalPriority( globalPriority_ )
-      {}
-
-      DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this) = rhs;
-      }
-
-      DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DeviceQueueGlobalPriorityCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceQueueGlobalPriorityCreateInfoEXT( globalPriority_ )
+      : globalPriority( globalPriority_ )
     {}
 
+    vk::DeviceQueueGlobalPriorityCreateInfoEXT & operator=( vk::DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueGlobalPriorityCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceQueueGlobalPriorityCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceQueueGlobalPriorityCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceQueueGlobalPriorityCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -31731,61 +30272,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceQueueGlobalPriorityCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::QueueGlobalPriorityEXT globalPriority;
   };
   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:
-      VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
-                                             uint32_t queueFamilyIndex_ = 0,
-                                             uint32_t queueIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , queueFamilyIndex( queueFamilyIndex_ )
-        , queueIndex( queueIndex_ )
-      {}
-
-      DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDeviceQueueInfo2*>(this) = rhs;
-      }
-
-      DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DeviceQueueInfo2
+  struct DeviceQueueInfo2
   {
     VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
                                            uint32_t queueFamilyIndex_ = 0,
                                            uint32_t queueIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceQueueInfo2( flags_, queueFamilyIndex_, queueIndex_ )
+      : flags( flags_ )
+      , queueFamilyIndex( queueFamilyIndex_ )
+      , queueIndex( queueIndex_ )
     {}
 
+    vk::DeviceQueueInfo2 & operator=( vk::DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueInfo2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DeviceQueueInfo2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DeviceQueueInfo2::operator=(rhs);
+      *this = *reinterpret_cast<vk::DeviceQueueInfo2 const *>(&rhs);
       return *this;
     }
 
@@ -31837,8 +30355,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DeviceQueueInfo2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDeviceQueueInfo2;
+    const void* pNext = nullptr;
+    vk::DeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueIndex;
   };
   static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DeviceQueueInfo2>::value, "struct wrapper is not a standard layout!" );
@@ -31855,12 +30377,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDispatchIndirectCommand*>(this) = rhs;
+      *this = rhs;
     }
 
     DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDispatchIndirectCommand*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DispatchIndirectCommand const *>(&rhs);
       return *this;
     }
 
@@ -31912,47 +30434,26 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT
-        : displayEvent( displayEvent_ )
-      {}
-
-      DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayEventInfoEXT*>(this) = rhs;
-      }
-
-      DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DisplayEventInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayEventInfoEXT( displayEvent_ )
+      : displayEvent( displayEvent_ )
     {}
 
+    vk::DisplayEventInfoEXT & operator=( vk::DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayEventInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayEventInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayEventInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayEventInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -31990,8 +30491,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayEventInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayEventInfoEXT;
+    const void* pNext = nullptr;
+    vk::DisplayEventTypeEXT displayEvent;
   };
   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!" );
@@ -32006,12 +30509,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayModeParametersKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayModeParametersKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DisplayModeParametersKHR const *>(&rhs);
       return *this;
     }
 
@@ -32055,51 +30558,28 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(),
-                                                     vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , parameters( parameters_ )
-      {}
-
-      DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this) = rhs;
-      }
-
-      DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct DisplayModeCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(),
                                                    vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayModeCreateInfoKHR( flags_, parameters_ )
+      : flags( flags_ )
+      , parameters( parameters_ )
     {}
 
+    vk::DisplayModeCreateInfoKHR & operator=( vk::DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayModeCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayModeCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayModeCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayModeCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -32144,25 +30624,31 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayModeCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
+    const void* pNext = nullptr;
+    vk::DisplayModeCreateFlagsKHR flags;
+    vk::DisplayModeParametersKHR parameters;
   };
   static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayModeCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayModePropertiesKHR
   {
-    DisplayModePropertiesKHR() VULKAN_HPP_NOEXCEPT
+    DisplayModePropertiesKHR( vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(),
+                              vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT
+      : displayMode( displayMode_ )
+      , parameters( parameters_ )
     {}
 
     DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayModePropertiesKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     DisplayModePropertiesKHR& operator=( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayModePropertiesKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DisplayModePropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -32194,46 +30680,26 @@ namespace VULKAN_HPP_NAMESPACE
   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
   {
-    struct DisplayModeProperties2KHR
-    {
-    protected:
-      DisplayModeProperties2KHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayModeProperties2KHR*>(this) = rhs;
-      }
-
-      DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::DisplayModeProperties2KHR
-  {
-    DisplayModeProperties2KHR() VULKAN_HPP_NOEXCEPT
-      : layout::DisplayModeProperties2KHR()
+    DisplayModeProperties2KHR( vk::DisplayModePropertiesKHR displayModeProperties_ = vk::DisplayModePropertiesKHR() ) VULKAN_HPP_NOEXCEPT
+      : displayModeProperties( displayModeProperties_ )
     {}
 
+    vk::DisplayModeProperties2KHR & operator=( vk::DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayModeProperties2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayModeProperties2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayModeProperties2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayModeProperties2KHR const *>(&rhs);
       return *this;
     }
 
@@ -32259,52 +30725,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayModeProperties2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayModeProperties2KHR;
+    void* pNext = nullptr;
+    vk::DisplayModePropertiesKHR displayModeProperties;
   };
   static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayModeProperties2KHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct DisplayNativeHdrSurfaceCapabilitiesAMD
   {
-    struct DisplayNativeHdrSurfaceCapabilitiesAMD
-    {
-    protected:
-      DisplayNativeHdrSurfaceCapabilitiesAMD() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(this) = rhs;
-      }
-
-      DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    DisplayNativeHdrSurfaceCapabilitiesAMD() VULKAN_HPP_NOEXCEPT
-      : layout::DisplayNativeHdrSurfaceCapabilitiesAMD()
+    DisplayNativeHdrSurfaceCapabilitiesAMD( vk::Bool32 localDimmingSupport_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : localDimmingSupport( localDimmingSupport_ )
     {}
 
+    vk::DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( vk::DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayNativeHdrSurfaceCapabilitiesAMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayNativeHdrSurfaceCapabilitiesAMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayNativeHdrSurfaceCapabilitiesAMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayNativeHdrSurfaceCapabilitiesAMD const *>(&rhs);
       return *this;
     }
 
@@ -32330,25 +30778,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayNativeHdrSurfaceCapabilitiesAMD::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD;
+    void* pNext = nullptr;
+    vk::Bool32 localDimmingSupport;
   };
   static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayNativeHdrSurfaceCapabilitiesAMD>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayPlaneCapabilitiesKHR
   {
-    DisplayPlaneCapabilitiesKHR() VULKAN_HPP_NOEXCEPT
+    DisplayPlaneCapabilitiesKHR( vk::DisplayPlaneAlphaFlagsKHR supportedAlpha_ = vk::DisplayPlaneAlphaFlagsKHR(),
+                                 vk::Offset2D minSrcPosition_ = vk::Offset2D(),
+                                 vk::Offset2D maxSrcPosition_ = vk::Offset2D(),
+                                 vk::Extent2D minSrcExtent_ = vk::Extent2D(),
+                                 vk::Extent2D maxSrcExtent_ = vk::Extent2D(),
+                                 vk::Offset2D minDstPosition_ = vk::Offset2D(),
+                                 vk::Offset2D maxDstPosition_ = vk::Offset2D(),
+                                 vk::Extent2D minDstExtent_ = vk::Extent2D(),
+                                 vk::Extent2D maxDstExtent_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT
+      : supportedAlpha( supportedAlpha_ )
+      , minSrcPosition( minSrcPosition_ )
+      , maxSrcPosition( maxSrcPosition_ )
+      , minSrcExtent( minSrcExtent_ )
+      , maxSrcExtent( maxSrcExtent_ )
+      , minDstPosition( minDstPosition_ )
+      , maxDstPosition( maxDstPosition_ )
+      , minDstExtent( minDstExtent_ )
+      , maxDstExtent( maxDstExtent_ )
     {}
 
     DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     DisplayPlaneCapabilitiesKHR& operator=( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DisplayPlaneCapabilitiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -32394,46 +30861,26 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct DisplayPlaneCapabilities2KHR
-    {
-    protected:
-      DisplayPlaneCapabilities2KHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this) = rhs;
-      }
-
-      DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DisplayPlaneCapabilities2KHR
   {
-    DisplayPlaneCapabilities2KHR() VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPlaneCapabilities2KHR()
+    DisplayPlaneCapabilities2KHR( vk::DisplayPlaneCapabilitiesKHR capabilities_ = vk::DisplayPlaneCapabilitiesKHR() ) VULKAN_HPP_NOEXCEPT
+      : capabilities( capabilities_ )
     {}
 
+    vk::DisplayPlaneCapabilities2KHR & operator=( vk::DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneCapabilities2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPlaneCapabilities2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayPlaneCapabilities2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayPlaneCapabilities2KHR const *>(&rhs);
       return *this;
     }
 
@@ -32459,57 +30906,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayPlaneCapabilities2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
+    void* pNext = nullptr;
+    vk::DisplayPlaneCapabilitiesKHR capabilities;
   };
   static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPlaneCapabilities2KHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DisplayPlaneInfo2KHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(),
-                                                 uint32_t planeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : mode( mode_ )
-        , planeIndex( planeIndex_ )
-      {}
-
-      DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this) = rhs;
-      }
-
-      DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DisplayPlaneInfo2KHR
   {
     VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(),
                                                uint32_t planeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPlaneInfo2KHR( mode_, planeIndex_ )
+      : mode( mode_ )
+      , planeIndex( planeIndex_ )
     {}
 
+    vk::DisplayPlaneInfo2KHR & operator=( vk::DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneInfo2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPlaneInfo2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayPlaneInfo2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayPlaneInfo2KHR const *>(&rhs);
       return *this;
     }
 
@@ -32554,25 +30980,31 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayPlaneInfo2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
+    const void* pNext = nullptr;
+    vk::DisplayModeKHR mode;
+    uint32_t planeIndex;
   };
   static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPlaneInfo2KHR>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayPlanePropertiesKHR
   {
-    DisplayPlanePropertiesKHR() VULKAN_HPP_NOEXCEPT
+    DisplayPlanePropertiesKHR( vk::DisplayKHR currentDisplay_ = vk::DisplayKHR(),
+                               uint32_t currentStackIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : currentDisplay( currentDisplay_ )
+      , currentStackIndex( currentStackIndex_ )
     {}
 
     DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     DisplayPlanePropertiesKHR& operator=( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DisplayPlanePropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -32604,46 +31036,26 @@ namespace VULKAN_HPP_NAMESPACE
   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
   {
-    struct DisplayPlaneProperties2KHR
-    {
-    protected:
-      DisplayPlaneProperties2KHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this) = rhs;
-      }
-
-      DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
-  {
-    DisplayPlaneProperties2KHR() VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPlaneProperties2KHR()
+    DisplayPlaneProperties2KHR( vk::DisplayPlanePropertiesKHR displayPlaneProperties_ = vk::DisplayPlanePropertiesKHR() ) VULKAN_HPP_NOEXCEPT
+      : displayPlaneProperties( displayPlaneProperties_ )
     {}
 
+    vk::DisplayPlaneProperties2KHR & operator=( vk::DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneProperties2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPlaneProperties2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayPlaneProperties2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayPlaneProperties2KHR const *>(&rhs);
       return *this;
     }
 
@@ -32669,53 +31081,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayPlaneProperties2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
+    void* pNext = nullptr;
+    vk::DisplayPlanePropertiesKHR displayPlaneProperties;
   };
   static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPlaneProperties2KHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DisplayPowerInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT
-        : powerState( powerState_ )
-      {}
-
-      DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayPowerInfoEXT*>(this) = rhs;
-      }
-
-      DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DisplayPowerInfoEXT
   {
     VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPowerInfoEXT( powerState_ )
+      : powerState( powerState_ )
     {}
 
+    vk::DisplayPowerInfoEXT & operator=( vk::DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPowerInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPowerInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayPowerInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayPowerInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -32753,61 +31146,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayPowerInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayPowerInfoEXT;
+    const void* pNext = nullptr;
+    vk::DisplayPowerStateEXT powerState;
   };
   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:
-      VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(),
-                                                  vk::Rect2D dstRect_ = vk::Rect2D(),
-                                                  vk::Bool32 persistent_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : srcRect( srcRect_ )
-        , dstRect( dstRect_ )
-        , persistent( persistent_ )
-      {}
-
-      DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayPresentInfoKHR*>(this) = rhs;
-      }
-
-      DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DisplayPresentInfoKHR
   {
     VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(),
                                                 vk::Rect2D dstRect_ = vk::Rect2D(),
                                                 vk::Bool32 persistent_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPresentInfoKHR( srcRect_, dstRect_, persistent_ )
+      : srcRect( srcRect_ )
+      , dstRect( dstRect_ )
+      , persistent( persistent_ )
     {}
 
+    vk::DisplayPresentInfoKHR & operator=( vk::DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPresentInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayPresentInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayPresentInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayPresentInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -32859,25 +31229,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayPresentInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayPresentInfoKHR;
+    const void* pNext = nullptr;
+    vk::Rect2D srcRect;
+    vk::Rect2D dstRect;
+    vk::Bool32 persistent;
   };
   static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayPresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct DisplayPropertiesKHR
   {
-    DisplayPropertiesKHR() VULKAN_HPP_NOEXCEPT
+    DisplayPropertiesKHR( vk::DisplayKHR display_ = vk::DisplayKHR(),
+                          const char* displayName_ = nullptr,
+                          vk::Extent2D physicalDimensions_ = vk::Extent2D(),
+                          vk::Extent2D physicalResolution_ = vk::Extent2D(),
+                          vk::SurfaceTransformFlagsKHR supportedTransforms_ = vk::SurfaceTransformFlagsKHR(),
+                          vk::Bool32 planeReorderPossible_ = 0,
+                          vk::Bool32 persistentContent_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : display( display_ )
+      , displayName( displayName_ )
+      , physicalDimensions( physicalDimensions_ )
+      , physicalResolution( physicalResolution_ )
+      , supportedTransforms( supportedTransforms_ )
+      , planeReorderPossible( planeReorderPossible_ )
+      , persistentContent( persistentContent_ )
     {}
 
     DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayPropertiesKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     DisplayPropertiesKHR& operator=( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDisplayPropertiesKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DisplayPropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -32919,46 +31306,26 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
+  struct DisplayProperties2KHR
   {
-    struct DisplayProperties2KHR
-    {
-    protected:
-      DisplayProperties2KHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplayProperties2KHR*>(this) = rhs;
-      }
-
-      DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    DisplayProperties2KHR() VULKAN_HPP_NOEXCEPT
-      : layout::DisplayProperties2KHR()
+    DisplayProperties2KHR( vk::DisplayPropertiesKHR displayProperties_ = vk::DisplayPropertiesKHR() ) VULKAN_HPP_NOEXCEPT
+      : displayProperties( displayProperties_ )
     {}
 
+    vk::DisplayProperties2KHR & operator=( vk::DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayProperties2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplayProperties2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplayProperties2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplayProperties2KHR const *>(&rhs);
       return *this;
     }
 
@@ -32984,62 +31351,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplayProperties2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDisplayProperties2KHR;
+    void* pNext = nullptr;
+    vk::DisplayPropertiesKHR displayProperties;
   };
   static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplayProperties2KHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct DisplaySurfaceCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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() ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , displayMode( displayMode_ )
-        , planeIndex( planeIndex_ )
-        , planeStackIndex( planeStackIndex_ )
-        , transform( transform_ )
-        , globalAlpha( globalAlpha_ )
-        , alphaMode( alphaMode_ )
-        , imageExtent( imageExtent_ )
-      {}
-
-      DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this) = rhs;
-      }
-
-      DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct DisplaySurfaceCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(),
                                                       vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(),
@@ -33049,16 +31369,30 @@ namespace VULKAN_HPP_NAMESPACE
                                                       float globalAlpha_ = 0,
                                                       vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque,
                                                       vk::Extent2D imageExtent_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplaySurfaceCreateInfoKHR( flags_, displayMode_, planeIndex_, planeStackIndex_, transform_, globalAlpha_, alphaMode_, imageExtent_ )
+      : flags( flags_ )
+      , displayMode( displayMode_ )
+      , planeIndex( planeIndex_ )
+      , planeStackIndex( planeStackIndex_ )
+      , transform( transform_ )
+      , globalAlpha( globalAlpha_ )
+      , alphaMode( alphaMode_ )
+      , imageExtent( imageExtent_ )
     {}
 
+    vk::DisplaySurfaceCreateInfoKHR & operator=( vk::DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplaySurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DisplaySurfaceCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DisplaySurfaceCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::DisplaySurfaceCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -33145,8 +31479,17 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DisplaySurfaceCreateInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DisplaySurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -33167,12 +31510,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this) = rhs;
+      *this = rhs;
     }
 
     DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DrawIndexedIndirectCommand const *>(&rhs);
       return *this;
     }
 
@@ -33254,12 +31597,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDrawIndirectCommand*>(this) = rhs;
+      *this = rhs;
     }
 
     DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDrawIndirectCommand*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DrawIndirectCommand const *>(&rhs);
       return *this;
     }
 
@@ -33329,12 +31672,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this) = rhs;
+      *this = rhs;
     }
 
     DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DrawMeshTasksIndirectCommandNV const *>(&rhs);
       return *this;
     }
 
@@ -33380,17 +31723,22 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct DrmFormatModifierPropertiesEXT
   {
-    DrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT
+    DrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = 0,
+                                    uint32_t drmFormatModifierPlaneCount_ = 0,
+                                    vk::FormatFeatureFlags drmFormatModifierTilingFeatures_ = vk::FormatFeatureFlags() ) VULKAN_HPP_NOEXCEPT
+      : drmFormatModifier( drmFormatModifier_ )
+      , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
+      , drmFormatModifierTilingFeatures( drmFormatModifierTilingFeatures_ )
     {}
 
     DrmFormatModifierPropertiesEXT( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>(this) = rhs;
+      *this = rhs;
     }
 
     DrmFormatModifierPropertiesEXT& operator=( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>(this) = rhs;
+      *this = *reinterpret_cast<vk::DrmFormatModifierPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -33424,47 +31772,28 @@ namespace VULKAN_HPP_NAMESPACE
   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
   {
-    struct DrmFormatModifierPropertiesListEXT
-    {
-    protected:
-      DrmFormatModifierPropertiesListEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this) = rhs;
-      }
-
-      DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
-  {
-    DrmFormatModifierPropertiesListEXT() VULKAN_HPP_NOEXCEPT
-      : layout::DrmFormatModifierPropertiesListEXT()
+    DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = 0,
+                                        vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : drmFormatModifierCount( drmFormatModifierCount_ )
+      , pDrmFormatModifierProperties( pDrmFormatModifierProperties_ )
     {}
 
+    vk::DrmFormatModifierPropertiesListEXT & operator=( vk::DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::DrmFormatModifierPropertiesListEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::DrmFormatModifierPropertiesListEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::DrmFormatModifierPropertiesListEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::DrmFormatModifierPropertiesListEXT const *>(&rhs);
       return *this;
     }
 
@@ -33491,53 +31820,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::DrmFormatModifierPropertiesListEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
+    void* pNext = nullptr;
+    uint32_t drmFormatModifierCount;
+    vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
   };
   static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<DrmFormatModifierPropertiesListEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct EventCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-      {}
-
-      EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkEventCreateInfo*>(this) = rhs;
-      }
-
-      EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkEventCreateInfo*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct EventCreateInfo
   {
     VULKAN_HPP_CONSTEXPR EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::EventCreateInfo( flags_ )
+      : flags( flags_ )
     {}
 
+    vk::EventCreateInfo & operator=( vk::EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::EventCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::EventCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::EventCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::EventCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -33575,53 +31886,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::EventCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eEventCreateInfo;
+    const void* pNext = nullptr;
+    vk::EventCreateFlags flags;
   };
   static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<EventCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ExportFenceCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-        : handleTypes( handleTypes_ )
-      {}
-
-      ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportFenceCreateInfo*>(this) = rhs;
-      }
-
-      ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExportFenceCreateInfo
   {
     VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportFenceCreateInfo( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {}
 
+    vk::ExportFenceCreateInfo & operator=( vk::ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportFenceCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportFenceCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExportFenceCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExportFenceCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -33659,63 +31951,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExportFenceCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExportFenceCreateInfo;
+    const void* pNext = nullptr;
+    vk::ExternalFenceHandleTypeFlags handleTypes;
   };
   static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportFenceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct ExportFenceWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
-                                                          DWORD dwAccess_ = 0,
-                                                          LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : pAttributes( pAttributes_ )
-        , dwAccess( dwAccess_ )
-        , name( name_ )
-      {}
-
-      ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExportFenceWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
                                                         DWORD dwAccess_ = 0,
                                                         LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportFenceWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
+      : pAttributes( pAttributes_ )
+      , dwAccess( dwAccess_ )
+      , name( name_ )
     {}
 
+    vk::ExportFenceWin32HandleInfoKHR & operator=( vk::ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportFenceWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportFenceWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExportFenceWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExportFenceWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -33767,54 +32036,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExportFenceWin32HandleInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
+    const void* pNext = nullptr;
+    const SECURITY_ATTRIBUTES* pAttributes;
+    DWORD dwAccess;
+    LPCWSTR name;
   };
   static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportFenceWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  namespace layout
-  {
-    struct ExportMemoryAllocateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-        : handleTypes( handleTypes_ )
-      {}
-
-      ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportMemoryAllocateInfo*>(this) = rhs;
-      }
-
-      ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExportMemoryAllocateInfo
   {
     VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportMemoryAllocateInfo( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {}
 
+    vk::ExportMemoryAllocateInfo & operator=( vk::ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryAllocateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportMemoryAllocateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExportMemoryAllocateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExportMemoryAllocateInfo const *>(&rhs);
       return *this;
     }
 
@@ -33852,53 +32104,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExportMemoryAllocateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExportMemoryAllocateInfo;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlags handleTypes;
   };
   static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportMemoryAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ExportMemoryAllocateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT
-        : handleTypes( handleTypes_ )
-      {}
-
-      ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this) = rhs;
-      }
-
-      ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct ExportMemoryAllocateInfoNV
   {
     VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportMemoryAllocateInfoNV( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {}
 
+    vk::ExportMemoryAllocateInfoNV & operator=( vk::ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryAllocateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportMemoryAllocateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExportMemoryAllocateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExportMemoryAllocateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -33936,63 +32169,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExportMemoryAllocateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlagsNV handleTypes;
   };
   static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct ExportMemoryWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
-                                                           DWORD dwAccess_ = 0,
-                                                           LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : pAttributes( pAttributes_ )
-        , dwAccess( dwAccess_ )
-        , name( name_ )
-      {}
-
-      ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExportMemoryWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
                                                          DWORD dwAccess_ = 0,
                                                          LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportMemoryWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
+      : pAttributes( pAttributes_ )
+      , dwAccess( dwAccess_ )
+      , name( name_ )
     {}
 
+    vk::ExportMemoryWin32HandleInfoKHR & operator=( vk::ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportMemoryWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExportMemoryWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExportMemoryWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -34044,8 +32254,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExportMemoryWin32HandleInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
+    const void* pNext = nullptr;
+    const SECURITY_ATTRIBUTES* pAttributes;
+    DWORD dwAccess;
+    LPCWSTR name;
   };
   static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -34053,51 +32267,28 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct ExportMemoryWin32HandleInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
-                                                          DWORD dwAccess_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : pAttributes( pAttributes_ )
-        , dwAccess( dwAccess_ )
-      {}
-
-      ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this) = rhs;
-      }
-
-      ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExportMemoryWin32HandleInfoNV
   {
     VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
                                                         DWORD dwAccess_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportMemoryWin32HandleInfoNV( pAttributes_, dwAccess_ )
+      : pAttributes( pAttributes_ )
+      , dwAccess( dwAccess_ )
     {}
 
+    vk::ExportMemoryWin32HandleInfoNV & operator=( vk::ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryWin32HandleInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportMemoryWin32HandleInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExportMemoryWin32HandleInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExportMemoryWin32HandleInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -34142,54 +32333,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExportMemoryWin32HandleInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
+    const void* pNext = nullptr;
+    const SECURITY_ATTRIBUTES* pAttributes;
+    DWORD dwAccess;
   };
   static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportMemoryWin32HandleInfoNV>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  namespace layout
-  {
-    struct ExportSemaphoreCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-        : handleTypes( handleTypes_ )
-      {}
-
-      ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this) = rhs;
-      }
-
-      ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExportSemaphoreCreateInfo
   {
     VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportSemaphoreCreateInfo( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {}
 
+    vk::ExportSemaphoreCreateInfo & operator=( vk::ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportSemaphoreCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportSemaphoreCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExportSemaphoreCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExportSemaphoreCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -34227,63 +32400,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExportSemaphoreCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExportSemaphoreCreateInfo;
+    const void* pNext = nullptr;
+    vk::ExternalSemaphoreHandleTypeFlags handleTypes;
   };
   static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportSemaphoreCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct ExportSemaphoreWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
-                                                              DWORD dwAccess_ = 0,
-                                                              LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : pAttributes( pAttributes_ )
-        , dwAccess( dwAccess_ )
-        , name( name_ )
-      {}
-
-      ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExportSemaphoreWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
                                                             DWORD dwAccess_ = 0,
                                                             LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportSemaphoreWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
+      : pAttributes( pAttributes_ )
+      , dwAccess( dwAccess_ )
+      , name( name_ )
     {}
 
+    vk::ExportSemaphoreWin32HandleInfoKHR & operator=( vk::ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportSemaphoreWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExportSemaphoreWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExportSemaphoreWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExportSemaphoreWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -34335,8 +32485,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExportSemaphoreWin32HandleInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
+    const void* pNext = nullptr;
+    const SECURITY_ATTRIBUTES* pAttributes;
+    DWORD dwAccess;
+    LPCWSTR name;
   };
   static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -34344,17 +32498,22 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExtensionProperties
   {
-    ExtensionProperties() VULKAN_HPP_NOEXCEPT
-    {}
+    ExtensionProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& extensionName_ = { { 0 } },
+                         uint32_t specVersion_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : extensionName{}
+      , specVersion( specVersion_ )
+    {
+      vk::ConstExpressionArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE,VK_MAX_EXTENSION_NAME_SIZE>::copy( extensionName, extensionName_ );
+    }
 
     ExtensionProperties( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExtensionProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     ExtensionProperties& operator=( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExtensionProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ExtensionProperties const *>(&rhs);
       return *this;
     }
 
@@ -34388,17 +32547,22 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExternalMemoryProperties
   {
-    ExternalMemoryProperties() VULKAN_HPP_NOEXCEPT
+    ExternalMemoryProperties( vk::ExternalMemoryFeatureFlags externalMemoryFeatures_ = vk::ExternalMemoryFeatureFlags(),
+                              vk::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalMemoryHandleTypeFlags(),
+                              vk::ExternalMemoryHandleTypeFlags compatibleHandleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
+      : externalMemoryFeatures( externalMemoryFeatures_ )
+      , exportFromImportedHandleTypes( exportFromImportedHandleTypes_ )
+      , compatibleHandleTypes( compatibleHandleTypes_ )
     {}
 
     ExternalMemoryProperties( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExternalMemoryProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     ExternalMemoryProperties& operator=( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExternalMemoryProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ExternalMemoryProperties const *>(&rhs);
       return *this;
     }
 
@@ -34432,46 +32596,26 @@ namespace VULKAN_HPP_NAMESPACE
   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
   {
-    struct ExternalBufferProperties
-    {
-    protected:
-      ExternalBufferProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalBufferProperties*>(this) = rhs;
-      }
-
-      ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    ExternalBufferProperties() VULKAN_HPP_NOEXCEPT
-      : layout::ExternalBufferProperties()
+    ExternalBufferProperties( vk::ExternalMemoryProperties externalMemoryProperties_ = vk::ExternalMemoryProperties() ) VULKAN_HPP_NOEXCEPT
+      : externalMemoryProperties( externalMemoryProperties_ )
     {}
 
+    vk::ExternalBufferProperties & operator=( vk::ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalBufferProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalBufferProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExternalBufferProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExternalBufferProperties const *>(&rhs);
       return *this;
     }
 
@@ -34497,54 +32641,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExternalBufferProperties::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExternalBufferProperties;
+    void* pNext = nullptr;
+    vk::ExternalMemoryProperties externalMemoryProperties;
   };
   static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalBufferProperties>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct ExternalFenceProperties
   {
-    struct ExternalFenceProperties
-    {
-    protected:
-      ExternalFenceProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalFenceProperties*>(this) = rhs;
-      }
-
-      ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    ExternalFenceProperties() VULKAN_HPP_NOEXCEPT
-      : layout::ExternalFenceProperties()
+    ExternalFenceProperties( vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalFenceHandleTypeFlags(),
+                             vk::ExternalFenceHandleTypeFlags compatibleHandleTypes_ = vk::ExternalFenceHandleTypeFlags(),
+                             vk::ExternalFenceFeatureFlags externalFenceFeatures_ = vk::ExternalFenceFeatureFlags() ) VULKAN_HPP_NOEXCEPT
+      : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ )
+      , compatibleHandleTypes( compatibleHandleTypes_ )
+      , externalFenceFeatures( externalFenceFeatures_ )
     {}
 
+    vk::ExternalFenceProperties & operator=( vk::ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalFenceProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalFenceProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExternalFenceProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExternalFenceProperties const *>(&rhs);
       return *this;
     }
 
@@ -34572,55 +32700,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExternalFenceProperties::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExternalFenceProperties;
+    void* pNext = nullptr;
+    vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
+    vk::ExternalFenceHandleTypeFlags compatibleHandleTypes;
+    vk::ExternalFenceFeatureFlags externalFenceFeatures;
   };
   static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalFenceProperties>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
-  namespace layout
-  {
-    struct ExternalFormatANDROID
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : externalFormat( externalFormat_ )
-      {}
-
-      ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalFormatANDROID*>(this) = rhs;
-      }
-
-      ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExternalFormatANDROID
   {
     VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalFormatANDROID( externalFormat_ )
+      : externalFormat( externalFormat_ )
     {}
 
+    vk::ExternalFormatANDROID & operator=( vk::ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalFormatANDROID ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalFormatANDROID( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExternalFormatANDROID::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExternalFormatANDROID const *>(&rhs);
       return *this;
     }
 
@@ -34658,53 +32769,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExternalFormatANDROID::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExternalFormatANDROID;
+    void* pNext = nullptr;
+    uint64_t externalFormat;
   };
   static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalFormatANDROID>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  namespace layout
+  struct ExternalImageFormatProperties
   {
-    struct ExternalImageFormatProperties
-    {
-    protected:
-      ExternalImageFormatProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalImageFormatProperties*>(this) = rhs;
-      }
-
-      ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    ExternalImageFormatProperties() VULKAN_HPP_NOEXCEPT
-      : layout::ExternalImageFormatProperties()
+    ExternalImageFormatProperties( vk::ExternalMemoryProperties externalMemoryProperties_ = vk::ExternalMemoryProperties() ) VULKAN_HPP_NOEXCEPT
+      : externalMemoryProperties( externalMemoryProperties_ )
     {}
 
+    vk::ExternalImageFormatProperties & operator=( vk::ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalImageFormatProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalImageFormatProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExternalImageFormatProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExternalImageFormatProperties const *>(&rhs);
       return *this;
     }
 
@@ -34730,25 +32823,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExternalImageFormatProperties::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExternalImageFormatProperties;
+    void* pNext = nullptr;
+    vk::ExternalMemoryProperties externalMemoryProperties;
   };
   static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
 
   struct ImageFormatProperties
   {
-    ImageFormatProperties() VULKAN_HPP_NOEXCEPT
+    ImageFormatProperties( vk::Extent3D maxExtent_ = vk::Extent3D(),
+                           uint32_t maxMipLevels_ = 0,
+                           uint32_t maxArrayLayers_ = 0,
+                           vk::SampleCountFlags sampleCounts_ = vk::SampleCountFlags(),
+                           vk::DeviceSize maxResourceSize_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxExtent( maxExtent_ )
+      , maxMipLevels( maxMipLevels_ )
+      , maxArrayLayers( maxArrayLayers_ )
+      , sampleCounts( sampleCounts_ )
+      , maxResourceSize( maxResourceSize_ )
     {}
 
     ImageFormatProperties( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageFormatProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     ImageFormatProperties& operator=( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageFormatProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ImageFormatProperties const *>(&rhs);
       return *this;
     }
 
@@ -34788,17 +32892,24 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExternalImageFormatPropertiesNV
   {
-    ExternalImageFormatPropertiesNV() VULKAN_HPP_NOEXCEPT
+    ExternalImageFormatPropertiesNV( vk::ImageFormatProperties imageFormatProperties_ = vk::ImageFormatProperties(),
+                                     vk::ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = vk::ExternalMemoryFeatureFlagsNV(),
+                                     vk::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV(),
+                                     vk::ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT
+      : imageFormatProperties( imageFormatProperties_ )
+      , externalMemoryFeatures( externalMemoryFeatures_ )
+      , exportFromImportedHandleTypes( exportFromImportedHandleTypes_ )
+      , compatibleHandleTypes( compatibleHandleTypes_ )
     {}
 
     ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this) = rhs;
+      *this = rhs;
     }
 
     ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ExternalImageFormatPropertiesNV const *>(&rhs);
       return *this;
     }
 
@@ -34834,47 +32945,26 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-        : handleTypes( handleTypes_ )
-      {}
-
-      ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this) = rhs;
-      }
-
-      ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct ExternalMemoryBufferCreateInfo
   {
     VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalMemoryBufferCreateInfo( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {}
 
+    vk::ExternalMemoryBufferCreateInfo & operator=( vk::ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryBufferCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalMemoryBufferCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExternalMemoryBufferCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExternalMemoryBufferCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -34912,53 +33002,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExternalMemoryBufferCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlags handleTypes;
   };
   static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalMemoryBufferCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ExternalMemoryImageCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-        : handleTypes( handleTypes_ )
-      {}
-
-      ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this) = rhs;
-      }
-
-      ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExternalMemoryImageCreateInfo
   {
     VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalMemoryImageCreateInfo( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {}
 
+    vk::ExternalMemoryImageCreateInfo & operator=( vk::ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryImageCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalMemoryImageCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExternalMemoryImageCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExternalMemoryImageCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -34996,53 +33067,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExternalMemoryImageCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlags handleTypes;
   };
   static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalMemoryImageCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ExternalMemoryImageCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT
-        : handleTypes( handleTypes_ )
-      {}
-
-      ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this) = rhs;
-      }
-
-      ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ExternalMemoryImageCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalMemoryImageCreateInfoNV( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {}
 
+    vk::ExternalMemoryImageCreateInfoNV & operator=( vk::ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryImageCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalMemoryImageCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExternalMemoryImageCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExternalMemoryImageCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -35080,54 +33132,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExternalMemoryImageCreateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlagsNV handleTypes;
   };
   static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalMemoryImageCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct ExternalSemaphoreProperties
   {
-    struct ExternalSemaphoreProperties
-    {
-    protected:
-      ExternalSemaphoreProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkExternalSemaphoreProperties*>(this) = rhs;
-      }
-
-      ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    ExternalSemaphoreProperties() VULKAN_HPP_NOEXCEPT
-      : layout::ExternalSemaphoreProperties()
+    ExternalSemaphoreProperties( vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalSemaphoreHandleTypeFlags(),
+                                 vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = vk::ExternalSemaphoreHandleTypeFlags(),
+                                 vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures_ = vk::ExternalSemaphoreFeatureFlags() ) VULKAN_HPP_NOEXCEPT
+      : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ )
+      , compatibleHandleTypes( compatibleHandleTypes_ )
+      , externalSemaphoreFeatures( externalSemaphoreFeatures_ )
     {}
 
+    vk::ExternalSemaphoreProperties & operator=( vk::ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalSemaphoreProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ExternalSemaphoreProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ExternalSemaphoreProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::ExternalSemaphoreProperties const *>(&rhs);
       return *this;
     }
 
@@ -35155,53 +33191,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ExternalSemaphoreProperties::sType;
+  public:
+    const vk::StructureType sType = StructureType::eExternalSemaphoreProperties;
+    void* pNext = nullptr;
+    vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
+    vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
+    vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
   };
   static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ExternalSemaphoreProperties>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct FenceCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-      {}
-
-      FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFenceCreateInfo*>(this) = rhs;
-      }
-
-      FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct FenceCreateInfo
   {
     VULKAN_HPP_CONSTEXPR FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::FenceCreateInfo( flags_ )
+      : flags( flags_ )
     {}
 
+    vk::FenceCreateInfo & operator=( vk::FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FenceCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FenceCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::FenceCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -35239,57 +33258,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FenceCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eFenceCreateInfo;
+    const void* pNext = nullptr;
+    vk::FenceCreateFlags flags;
   };
   static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FenceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct FenceGetFdInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(),
-                                              vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : fence( fence_ )
-        , handleType( handleType_ )
-      {}
-
-      FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFenceGetFdInfoKHR*>(this) = rhs;
-      }
-
-      FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct FenceGetFdInfoKHR
   {
     VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(),
                                             vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::FenceGetFdInfoKHR( fence_, handleType_ )
+      : fence( fence_ )
+      , handleType( handleType_ )
     {}
 
+    vk::FenceGetFdInfoKHR & operator=( vk::FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceGetFdInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FenceGetFdInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FenceGetFdInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::FenceGetFdInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -35334,59 +33332,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FenceGetFdInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eFenceGetFdInfoKHR;
+    const void* pNext = nullptr;
+    vk::Fence fence;
+    vk::ExternalFenceHandleTypeFlagBits handleType;
   };
   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
 
-  namespace layout
-  {
-    struct FenceGetWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
-                                                       vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : fence( fence_ )
-        , handleType( handleType_ )
-      {}
-
-      FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct FenceGetWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
                                                      vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::FenceGetWin32HandleInfoKHR( fence_, handleType_ )
+      : fence( fence_ )
+      , handleType( handleType_ )
     {}
 
+    vk::FenceGetWin32HandleInfoKHR & operator=( vk::FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FenceGetWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FenceGetWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::FenceGetWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -35431,54 +33409,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FenceGetWin32HandleInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
+    const void* pNext = nullptr;
+    vk::Fence fence;
+    vk::ExternalFenceHandleTypeFlagBits handleType;
   };
   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*/
 
-  namespace layout
+  struct FilterCubicImageViewImageFormatPropertiesEXT
   {
-    struct FilterCubicImageViewImageFormatPropertiesEXT
-    {
-    protected:
-      FilterCubicImageViewImageFormatPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(this) = rhs;
-      }
-
-      FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    FilterCubicImageViewImageFormatPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::FilterCubicImageViewImageFormatPropertiesEXT()
+    FilterCubicImageViewImageFormatPropertiesEXT( vk::Bool32 filterCubic_ = 0,
+                                                  vk::Bool32 filterCubicMinmax_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : filterCubic( filterCubic_ )
+      , filterCubicMinmax( filterCubicMinmax_ )
     {}
 
+    vk::FilterCubicImageViewImageFormatPropertiesEXT & operator=( vk::FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FilterCubicImageViewImageFormatPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FilterCubicImageViewImageFormatPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FilterCubicImageViewImageFormatPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::FilterCubicImageViewImageFormatPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -35505,25 +33467,33 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FilterCubicImageViewImageFormatPropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 filterCubic;
+    vk::Bool32 filterCubicMinmax;
   };
   static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FilterCubicImageViewImageFormatPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct FormatProperties
   {
-    FormatProperties() VULKAN_HPP_NOEXCEPT
+    FormatProperties( vk::FormatFeatureFlags linearTilingFeatures_ = vk::FormatFeatureFlags(),
+                      vk::FormatFeatureFlags optimalTilingFeatures_ = vk::FormatFeatureFlags(),
+                      vk::FormatFeatureFlags bufferFeatures_ = vk::FormatFeatureFlags() ) VULKAN_HPP_NOEXCEPT
+      : linearTilingFeatures( linearTilingFeatures_ )
+      , optimalTilingFeatures( optimalTilingFeatures_ )
+      , bufferFeatures( bufferFeatures_ )
     {}
 
     FormatProperties( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkFormatProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     FormatProperties& operator=( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkFormatProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::FormatProperties const *>(&rhs);
       return *this;
     }
 
@@ -35557,46 +33527,26 @@ namespace VULKAN_HPP_NAMESPACE
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFormatProperties2*>(this) = rhs;
-      }
-
-      FormatProperties2& operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFormatProperties2*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct FormatProperties2
   {
-    FormatProperties2() VULKAN_HPP_NOEXCEPT
-      : layout::FormatProperties2()
+    FormatProperties2( vk::FormatProperties formatProperties_ = vk::FormatProperties() ) VULKAN_HPP_NOEXCEPT
+      : formatProperties( formatProperties_ )
     {}
 
+    vk::FormatProperties2 & operator=( vk::FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FormatProperties2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FormatProperties2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FormatProperties2& operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FormatProperties2::operator=(rhs);
+      *this = *reinterpret_cast<vk::FormatProperties2 const *>(&rhs);
       return *this;
     }
 
@@ -35622,59 +33572,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FormatProperties2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eFormatProperties2;
+    void* pNext = nullptr;
+    vk::FormatProperties formatProperties;
   };
   static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FormatProperties2>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct FramebufferAttachmentImageInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , usage( usage_ )
-        , width( width_ )
-        , height( height_ )
-        , layerCount( layerCount_ )
-        , viewFormatCount( viewFormatCount_ )
-        , pViewFormats( pViewFormats_ )
-      {}
-
-      FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
-      }
-
-      FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct FramebufferAttachmentImageInfoKHR
   {
     VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
                                                             vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
@@ -35683,16 +33589,29 @@ namespace VULKAN_HPP_NAMESPACE
                                                             uint32_t layerCount_ = 0,
                                                             uint32_t viewFormatCount_ = 0,
                                                             const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::FramebufferAttachmentImageInfoKHR( flags_, usage_, width_, height_, layerCount_, viewFormatCount_, pViewFormats_ )
+      : flags( flags_ )
+      , usage( usage_ )
+      , width( width_ )
+      , height( height_ )
+      , layerCount( layerCount_ )
+      , viewFormatCount( viewFormatCount_ )
+      , pViewFormats( pViewFormats_ )
     {}
 
+    vk::FramebufferAttachmentImageInfoKHR & operator=( vk::FramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferAttachmentImageInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FramebufferAttachmentImageInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FramebufferAttachmentImageInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::FramebufferAttachmentImageInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -35772,57 +33691,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FramebufferAttachmentImageInfoKHR::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0,
-                                                                const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : attachmentImageInfoCount( attachmentImageInfoCount_ )
-        , pAttachmentImageInfos( pAttachmentImageInfos_ )
-      {}
-
-      FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
-      }
-
-      FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::FramebufferAttachmentsCreateInfoKHR
+  struct FramebufferAttachmentsCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0,
                                                               const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::FramebufferAttachmentsCreateInfoKHR( attachmentImageInfoCount_, pAttachmentImageInfos_ )
+      : attachmentImageInfoCount( attachmentImageInfoCount_ )
+      , pAttachmentImageInfos( pAttachmentImageInfos_ )
     {}
 
+    vk::FramebufferAttachmentsCreateInfoKHR & operator=( vk::FramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferAttachmentsCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FramebufferAttachmentsCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FramebufferAttachmentsCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::FramebufferAttachmentsCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -35867,59 +33771,16 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FramebufferAttachmentsCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR;
+    const void* pNext = nullptr;
+    uint32_t attachmentImageInfoCount;
+    const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos;
   };
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , renderPass( renderPass_ )
-        , attachmentCount( attachmentCount_ )
-        , pAttachments( pAttachments_ )
-        , width( width_ )
-        , height( height_ )
-        , layers( layers_ )
-      {}
-
-      FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFramebufferCreateInfo*>(this) = rhs;
-      }
-
-      FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct FramebufferCreateInfo
   {
     VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(),
                                                 vk::RenderPass renderPass_ = vk::RenderPass(),
@@ -35928,16 +33789,29 @@ namespace VULKAN_HPP_NAMESPACE
                                                 uint32_t width_ = 0,
                                                 uint32_t height_ = 0,
                                                 uint32_t layers_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::FramebufferCreateInfo( flags_, renderPass_, attachmentCount_, pAttachments_, width_, height_, layers_ )
+      : flags( flags_ )
+      , renderPass( renderPass_ )
+      , attachmentCount( attachmentCount_ )
+      , pAttachments( pAttachments_ )
+      , width( width_ )
+      , height( height_ )
+      , layers( layers_ )
     {}
 
+    vk::FramebufferCreateInfo & operator=( vk::FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FramebufferCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FramebufferCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::FramebufferCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -36017,55 +33891,46 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FramebufferCreateInfo::sType;
+  public:
+    const 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 ), "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
   {
-    struct FramebufferMixedSamplesCombinationNV
-    {
-    protected:
-      FramebufferMixedSamplesCombinationNV() VULKAN_HPP_NOEXCEPT
-      {}
-
-      FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(this) = rhs;
-      }
-
-      FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
-  {
-    FramebufferMixedSamplesCombinationNV() VULKAN_HPP_NOEXCEPT
-      : layout::FramebufferMixedSamplesCombinationNV()
+    FramebufferMixedSamplesCombinationNV( vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge,
+                                          vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1,
+                                          vk::SampleCountFlags depthStencilSamples_ = vk::SampleCountFlags(),
+                                          vk::SampleCountFlags colorSamples_ = vk::SampleCountFlags() ) VULKAN_HPP_NOEXCEPT
+      : coverageReductionMode( coverageReductionMode_ )
+      , rasterizationSamples( rasterizationSamples_ )
+      , depthStencilSamples( depthStencilSamples_ )
+      , colorSamples( colorSamples_ )
     {}
 
+    vk::FramebufferMixedSamplesCombinationNV & operator=( vk::FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferMixedSamplesCombinationNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::FramebufferMixedSamplesCombinationNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::FramebufferMixedSamplesCombinationNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::FramebufferMixedSamplesCombinationNV const *>(&rhs);
       return *this;
     }
 
@@ -36094,8 +33959,13 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::FramebufferMixedSamplesCombinationNV::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<FramebufferMixedSamplesCombinationNV>::value, "struct wrapper is not a standard layout!" );
@@ -36112,12 +33982,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkVertexInputBindingDescription*>(this) = rhs;
+      *this = rhs;
     }
 
     VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkVertexInputBindingDescription*>(this) = rhs;
+      *this = *reinterpret_cast<vk::VertexInputBindingDescription const *>(&rhs);
       return *this;
     }
 
@@ -36183,12 +34053,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkVertexInputAttributeDescription*>(this) = rhs;
+      *this = rhs;
     }
 
     VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkVertexInputAttributeDescription*>(this) = rhs;
+      *this = *reinterpret_cast<vk::VertexInputAttributeDescription const *>(&rhs);
       return *this;
     }
 
@@ -36248,63 +34118,34 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct PipelineVertexInputStateCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(),
-                                                               uint32_t vertexBindingDescriptionCount_ = 0,
-                                                               const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
-                                                               uint32_t vertexAttributeDescriptionCount_ = 0,
-                                                               const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
-        , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
-        , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
-        , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
-      {}
-
-      PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineVertexInputStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(),
                                                              uint32_t vertexBindingDescriptionCount_ = 0,
                                                              const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
                                                              uint32_t vertexAttributeDescriptionCount_ = 0,
                                                              const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineVertexInputStateCreateInfo( flags_, vertexBindingDescriptionCount_, pVertexBindingDescriptions_, vertexAttributeDescriptionCount_, pVertexAttributeDescriptions_ )
+      : flags( flags_ )
+      , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
+      , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
+      , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
+      , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
     {}
 
+    vk::PipelineVertexInputStateCreateInfo & operator=( vk::PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineVertexInputStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineVertexInputStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineVertexInputStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineVertexInputStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -36370,61 +34211,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineVertexInputStateCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(),
-                                                                 vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList,
-                                                                 vk::Bool32 primitiveRestartEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , topology( topology_ )
-        , primitiveRestartEnable( primitiveRestartEnable_ )
-      {}
-
-      PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineInputAssemblyStateCreateInfo
+  struct PipelineInputAssemblyStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(),
                                                                vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList,
                                                                vk::Bool32 primitiveRestartEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineInputAssemblyStateCreateInfo( flags_, topology_, primitiveRestartEnable_ )
+      : flags( flags_ )
+      , topology( topology_ )
+      , primitiveRestartEnable( primitiveRestartEnable_ )
     {}
 
+    vk::PipelineInputAssemblyStateCreateInfo & operator=( vk::PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineInputAssemblyStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineInputAssemblyStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineInputAssemblyStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineInputAssemblyStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -36476,57 +34298,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineInputAssemblyStateCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
+    const void* pNext = nullptr;
+    vk::PipelineInputAssemblyStateCreateFlags flags;
+    vk::PrimitiveTopology topology;
+    vk::Bool32 primitiveRestartEnable;
   };
   static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineInputAssemblyStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineTessellationStateCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(),
-                                                                uint32_t patchControlPoints_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , patchControlPoints( patchControlPoints_ )
-      {}
-
-      PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PipelineTessellationStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(),
                                                               uint32_t patchControlPoints_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineTessellationStateCreateInfo( flags_, patchControlPoints_ )
+      : flags( flags_ )
+      , patchControlPoints( patchControlPoints_ )
     {}
 
+    vk::PipelineTessellationStateCreateInfo & operator=( vk::PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineTessellationStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineTessellationStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineTessellationStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineTessellationStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -36571,8 +34374,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineTessellationStateCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
+    const void* pNext = nullptr;
+    vk::PipelineTessellationStateCreateFlags flags;
+    uint32_t patchControlPoints;
   };
   static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineTessellationStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
@@ -36595,12 +34401,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkViewport*>(this) = rhs;
+      *this = rhs;
     }
 
     Viewport& operator=( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkViewport*>(this) = rhs;
+      *this = *reinterpret_cast<vk::Viewport const *>(&rhs);
       return *this;
     }
 
@@ -36676,63 +34482,34 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(),
-                                                            uint32_t viewportCount_ = 0,
-                                                            const vk::Viewport* pViewports_ = nullptr,
-                                                            uint32_t scissorCount_ = 0,
-                                                            const vk::Rect2D* pScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , viewportCount( viewportCount_ )
-        , pViewports( pViewports_ )
-        , scissorCount( scissorCount_ )
-        , pScissors( pScissors_ )
-      {}
-
-      PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineViewportStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(),
                                                           uint32_t viewportCount_ = 0,
                                                           const vk::Viewport* pViewports_ = nullptr,
                                                           uint32_t scissorCount_ = 0,
                                                           const vk::Rect2D* pScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportStateCreateInfo( flags_, viewportCount_, pViewports_, scissorCount_, pScissors_ )
+      : flags( flags_ )
+      , viewportCount( viewportCount_ )
+      , pViewports( pViewports_ )
+      , scissorCount( scissorCount_ )
+      , pScissors( pScissors_ )
     {}
 
+    vk::PipelineViewportStateCreateInfo & operator=( vk::PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineViewportStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineViewportStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -36798,71 +34575,19 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineViewportStateCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineRasterizationStateCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : 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 ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineRasterizationStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(),
                                                                vk::Bool32 depthClampEnable_ = 0,
@@ -36875,16 +34600,33 @@ namespace VULKAN_HPP_NAMESPACE
                                                                float depthBiasClamp_ = 0,
                                                                float depthBiasSlopeFactor_ = 0,
                                                                float lineWidth_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationStateCreateInfo( flags_, depthClampEnable_, rasterizerDiscardEnable_, polygonMode_, cullMode_, frontFace_, depthBiasEnable_, depthBiasConstantFactor_, depthBiasClamp_, depthBiasSlopeFactor_, lineWidth_ )
+      : flags( flags_ )
+      , depthClampEnable( depthClampEnable_ )
+      , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
+      , polygonMode( polygonMode_ )
+      , cullMode( cullMode_ )
+      , frontFace( frontFace_ )
+      , depthBiasEnable( depthBiasEnable_ )
+      , depthBiasConstantFactor( depthBiasConstantFactor_ )
+      , depthBiasClamp( depthBiasClamp_ )
+      , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
+      , lineWidth( lineWidth_ )
     {}
 
+    vk::PipelineRasterizationStateCreateInfo & operator=( vk::PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineRasterizationStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineRasterizationStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -36992,59 +34734,25 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineRasterizationStateCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , rasterizationSamples( rasterizationSamples_ )
-        , sampleShadingEnable( sampleShadingEnable_ )
-        , minSampleShading( minSampleShading_ )
-        , pSampleMask( pSampleMask_ )
-        , alphaToCoverageEnable( alphaToCoverageEnable_ )
-        , alphaToOneEnable( alphaToOneEnable_ )
-      {}
-
-      PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineMultisampleStateCreateInfo
+  struct PipelineMultisampleStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(),
                                                              vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1,
@@ -37053,16 +34761,29 @@ namespace VULKAN_HPP_NAMESPACE
                                                              const vk::SampleMask* pSampleMask_ = nullptr,
                                                              vk::Bool32 alphaToCoverageEnable_ = 0,
                                                              vk::Bool32 alphaToOneEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineMultisampleStateCreateInfo( flags_, rasterizationSamples_, sampleShadingEnable_, minSampleShading_, pSampleMask_, alphaToCoverageEnable_, alphaToOneEnable_ )
+      : flags( flags_ )
+      , rasterizationSamples( rasterizationSamples_ )
+      , sampleShadingEnable( sampleShadingEnable_ )
+      , minSampleShading( minSampleShading_ )
+      , pSampleMask( pSampleMask_ )
+      , alphaToCoverageEnable( alphaToCoverageEnable_ )
+      , alphaToOneEnable( alphaToOneEnable_ )
     {}
 
+    vk::PipelineMultisampleStateCreateInfo & operator=( vk::PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineMultisampleStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineMultisampleStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineMultisampleStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineMultisampleStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -37142,8 +34863,16 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineMultisampleStateCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineMultisampleStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
@@ -37168,12 +34897,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkStencilOpState*>(this) = rhs;
+      *this = rhs;
     }
 
     StencilOpState& operator=( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkStencilOpState*>(this) = rhs;
+      *this = *reinterpret_cast<vk::StencilOpState const *>(&rhs);
       return *this;
     }
 
@@ -37257,62 +34986,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , depthTestEnable( depthTestEnable_ )
-        , depthWriteEnable( depthWriteEnable_ )
-        , depthCompareOp( depthCompareOp_ )
-        , depthBoundsTestEnable( depthBoundsTestEnable_ )
-        , stencilTestEnable( stencilTestEnable_ )
-        , front( front_ )
-        , back( back_ )
-        , minDepthBounds( minDepthBounds_ )
-        , maxDepthBounds( maxDepthBounds_ )
-      {}
-
-      PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineDepthStencilStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(),
                                                               vk::Bool32 depthTestEnable_ = 0,
@@ -37324,16 +34998,32 @@ namespace VULKAN_HPP_NAMESPACE
                                                               vk::StencilOpState back_ = vk::StencilOpState(),
                                                               float minDepthBounds_ = 0,
                                                               float maxDepthBounds_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineDepthStencilStateCreateInfo( flags_, depthTestEnable_, depthWriteEnable_, depthCompareOp_, depthBoundsTestEnable_, stencilTestEnable_, front_, back_, minDepthBounds_, maxDepthBounds_ )
+      : flags( flags_ )
+      , depthTestEnable( depthTestEnable_ )
+      , depthWriteEnable( depthWriteEnable_ )
+      , depthCompareOp( depthCompareOp_ )
+      , depthBoundsTestEnable( depthBoundsTestEnable_ )
+      , stencilTestEnable( stencilTestEnable_ )
+      , front( front_ )
+      , back( back_ )
+      , minDepthBounds( minDepthBounds_ )
+      , maxDepthBounds( maxDepthBounds_ )
     {}
 
+    vk::PipelineDepthStencilStateCreateInfo & operator=( vk::PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDepthStencilStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineDepthStencilStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineDepthStencilStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineDepthStencilStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -37434,8 +35124,19 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineDepthStencilStateCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineDepthStencilStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
@@ -37462,12 +35163,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this) = rhs;
+      *this = rhs;
     }
 
     PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PipelineColorBlendAttachmentState const *>(&rhs);
       return *this;
     }
 
@@ -37559,52 +35260,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR_14 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 } } ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , logicOpEnable( logicOpEnable_ )
-        , logicOp( logicOp_ )
-        , attachmentCount( attachmentCount_ )
-        , pAttachments( pAttachments_ )
-        , blendConstants{}
-      {
-        vk::ConstExpressionArrayCopy<float,4,4>::copy( blendConstants, blendConstants_ );
-      }
-
-      PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PipelineColorBlendStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(),
                                                                vk::Bool32 logicOpEnable_ = 0,
@@ -37612,16 +35268,30 @@ namespace VULKAN_HPP_NAMESPACE
                                                                uint32_t attachmentCount_ = 0,
                                                                const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
                                                                std::array<float,4> const& blendConstants_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineColorBlendStateCreateInfo( flags_, logicOpEnable_, logicOp_, attachmentCount_, pAttachments_, blendConstants_ )
-    {}
+      : flags( flags_ )
+      , logicOpEnable( logicOpEnable_ )
+      , logicOp( logicOp_ )
+      , attachmentCount( attachmentCount_ )
+      , pAttachments( pAttachments_ )
+      , blendConstants{}
+    {
+      vk::ConstExpressionArrayCopy<float,4,4>::copy( blendConstants, blendConstants_ );
+    }
+
+    vk::PipelineColorBlendStateCreateInfo & operator=( vk::PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineColorBlendStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineColorBlendStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineColorBlendStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineColorBlendStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -37694,61 +35364,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineColorBlendStateCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(),
-                                                           uint32_t dynamicStateCount_ = 0,
-                                                           const vk::DynamicState* pDynamicStates_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , dynamicStateCount( dynamicStateCount_ )
-        , pDynamicStates( pDynamicStates_ )
-      {}
-
-      PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineDynamicStateCreateInfo
+  struct PipelineDynamicStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(),
                                                          uint32_t dynamicStateCount_ = 0,
                                                          const vk::DynamicState* pDynamicStates_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineDynamicStateCreateInfo( flags_, dynamicStateCount_, pDynamicStates_ )
+      : flags( flags_ )
+      , dynamicStateCount( dynamicStateCount_ )
+      , pDynamicStates( pDynamicStates_ )
     {}
 
+    vk::PipelineDynamicStateCreateInfo & operator=( vk::PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDynamicStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineDynamicStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineDynamicStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineDynamicStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -37800,89 +35452,17 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineDynamicStateCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : 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 ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this) = rhs;
-      }
-
-      GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct GraphicsPipelineCreateInfo
   {
     VULKAN_HPP_CONSTEXPR GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
                                                      uint32_t stageCount_ = 0,
@@ -37901,16 +35481,39 @@ namespace VULKAN_HPP_NAMESPACE
                                                      uint32_t subpass_ = 0,
                                                      vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
                                                      int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::GraphicsPipelineCreateInfo( flags_, stageCount_, pStages_, pVertexInputState_, pInputAssemblyState_, pTessellationState_, pViewportState_, pRasterizationState_, pMultisampleState_, pDepthStencilState_, pColorBlendState_, pDynamicState_, layout_, renderPass_, subpass_, basePipelineHandle_, basePipelineIndex_ )
+      : 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_ )
     {}
 
+    vk::GraphicsPipelineCreateInfo & operator=( vk::GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::GraphicsPipelineCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::GraphicsPipelineCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::GraphicsPipelineCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::GraphicsPipelineCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -38060,8 +35663,26 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::GraphicsPipelineCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<GraphicsPipelineCreateInfo>::value, "struct wrapper is not a standard layout!" );
@@ -38076,12 +35697,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkXYColorEXT*>(this) = rhs;
+      *this = rhs;
     }
 
     XYColorEXT& operator=( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkXYColorEXT*>(this) = rhs;
+      *this = *reinterpret_cast<vk::XYColorEXT const *>(&rhs);
       return *this;
     }
 
@@ -38125,56 +35746,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : displayPrimaryRed( displayPrimaryRed_ )
-        , displayPrimaryGreen( displayPrimaryGreen_ )
-        , displayPrimaryBlue( displayPrimaryBlue_ )
-        , whitePoint( whitePoint_ )
-        , maxLuminance( maxLuminance_ )
-        , minLuminance( minLuminance_ )
-        , maxContentLightLevel( maxContentLightLevel_ )
-        , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
-      {}
-
-      HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkHdrMetadataEXT*>(this) = rhs;
-      }
-
-      HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct HdrMetadataEXT
   {
     VULKAN_HPP_CONSTEXPR HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(),
                                          vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(),
@@ -38184,16 +35756,30 @@ namespace VULKAN_HPP_NAMESPACE
                                          float minLuminance_ = 0,
                                          float maxContentLightLevel_ = 0,
                                          float maxFrameAverageLightLevel_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::HdrMetadataEXT( displayPrimaryRed_, displayPrimaryGreen_, displayPrimaryBlue_, whitePoint_, maxLuminance_, minLuminance_, maxContentLightLevel_, maxFrameAverageLightLevel_ )
+      : displayPrimaryRed( displayPrimaryRed_ )
+      , displayPrimaryGreen( displayPrimaryGreen_ )
+      , displayPrimaryBlue( displayPrimaryBlue_ )
+      , whitePoint( whitePoint_ )
+      , maxLuminance( maxLuminance_ )
+      , minLuminance( minLuminance_ )
+      , maxContentLightLevel( maxContentLightLevel_ )
+      , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
     {}
 
+    vk::HdrMetadataEXT & operator=( vk::HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::HdrMetadataEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::HdrMetadataEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::HdrMetadataEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::HdrMetadataEXT const *>(&rhs);
       return *this;
     }
 
@@ -38280,53 +35866,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::HdrMetadataEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-      {}
-
-      HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(this) = rhs;
-      }
-
-      HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::HeadlessSurfaceCreateInfoEXT
+  struct HeadlessSurfaceCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() ) VULKAN_HPP_NOEXCEPT
-      : layout::HeadlessSurfaceCreateInfoEXT( flags_ )
+      : flags( flags_ )
     {}
 
+    vk::HeadlessSurfaceCreateInfoEXT & operator=( vk::HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::HeadlessSurfaceCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::HeadlessSurfaceCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::HeadlessSurfaceCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::HeadlessSurfaceCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -38364,59 +35938,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::HeadlessSurfaceCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::HeadlessSurfaceCreateFlagsEXT flags;
   };
   static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<HeadlessSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_IOS_MVK
 
-  namespace layout
-  {
-    struct IOSSurfaceCreateInfoMVK
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(),
-                                                    const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , pView( pView_ )
-      {}
-
-      IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this) = rhs;
-      }
-
-      IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct IOSSurfaceCreateInfoMVK
   {
     VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(),
                                                   const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::IOSSurfaceCreateInfoMVK( flags_, pView_ )
+      : flags( flags_ )
+      , pView( pView_ )
     {}
 
+    vk::IOSSurfaceCreateInfoMVK & operator=( vk::IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::IOSSurfaceCreateInfoMVK ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::IOSSurfaceCreateInfoMVK( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::IOSSurfaceCreateInfoMVK::operator=(rhs);
+      *this = *reinterpret_cast<vk::IOSSurfaceCreateInfoMVK const *>(&rhs);
       return *this;
     }
 
@@ -38461,8 +36014,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::IOSSurfaceCreateInfoMVK::sType;
+  public:
+    const vk::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
+    const void* pNext = nullptr;
+    vk::IOSSurfaceCreateFlagsMVK flags;
+    const void* pView;
   };
   static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<IOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" );
@@ -38485,12 +36041,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ImageBlit( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageBlit*>(this) = rhs;
+      *this = rhs;
     }
 
     ImageBlit& operator=( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageBlit*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ImageBlit const *>(&rhs);
       return *this;
     }
 
@@ -38566,12 +36122,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ImageCopy( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageCopy*>(this) = rhs;
+      *this = rhs;
     }
 
     ImageCopy& operator=( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageCopy*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ImageCopy const *>(&rhs);
       return *this;
     }
 
@@ -38639,71 +36195,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : 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_ )
-      {}
-
-      ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageCreateInfo*>(this) = rhs;
-      }
-
-      ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImageCreateInfo
   {
     VULKAN_HPP_CONSTEXPR ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
                                           vk::ImageType imageType_ = vk::ImageType::e1D,
@@ -38718,16 +36210,35 @@ namespace VULKAN_HPP_NAMESPACE
                                           uint32_t queueFamilyIndexCount_ = 0,
                                           const uint32_t* pQueueFamilyIndices_ = nullptr,
                                           vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageCreateInfo( flags_, imageType_, format_, extent_, mipLevels_, arrayLayers_, samples_, tiling_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, initialLayout_ )
+      : 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::ImageCreateInfo & operator=( vk::ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -38849,25 +36360,48 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
   struct SubresourceLayout
   {
-    SubresourceLayout() VULKAN_HPP_NOEXCEPT
+    SubresourceLayout( vk::DeviceSize offset_ = 0,
+                       vk::DeviceSize size_ = 0,
+                       vk::DeviceSize rowPitch_ = 0,
+                       vk::DeviceSize arrayPitch_ = 0,
+                       vk::DeviceSize depthPitch_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : offset( offset_ )
+      , size( size_ )
+      , rowPitch( rowPitch_ )
+      , arrayPitch( arrayPitch_ )
+      , depthPitch( depthPitch_ )
     {}
 
     SubresourceLayout( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSubresourceLayout*>(this) = rhs;
+      *this = rhs;
     }
 
     SubresourceLayout& operator=( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSubresourceLayout*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SubresourceLayout const *>(&rhs);
       return *this;
     }
 
@@ -38905,55 +36439,30 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
-                                                                        uint32_t drmFormatModifierPlaneCount_ = 0,
-                                                                        const vk::SubresourceLayout* pPlaneLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : drmFormatModifier( drmFormatModifier_ )
-        , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
-        , pPlaneLayouts( pPlaneLayouts_ )
-      {}
-
-      ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this) = rhs;
-      }
-
-      ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ImageDrmFormatModifierExplicitCreateInfoEXT
+  struct ImageDrmFormatModifierExplicitCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
                                                                       uint32_t drmFormatModifierPlaneCount_ = 0,
                                                                       const vk::SubresourceLayout* pPlaneLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( drmFormatModifier_, drmFormatModifierPlaneCount_, pPlaneLayouts_ )
+      : drmFormatModifier( drmFormatModifier_ )
+      , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
+      , pPlaneLayouts( pPlaneLayouts_ )
     {}
 
+    vk::ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( vk::ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierExplicitCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageDrmFormatModifierExplicitCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageDrmFormatModifierExplicitCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -39005,57 +36514,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageDrmFormatModifierExplicitCreateInfoEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
-                                                                    const uint64_t* pDrmFormatModifiers_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : drmFormatModifierCount( drmFormatModifierCount_ )
-        , pDrmFormatModifiers( pDrmFormatModifiers_ )
-      {}
-
-      ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this) = rhs;
-      }
-
-      ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImageDrmFormatModifierListCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
                                                                   const uint64_t* pDrmFormatModifiers_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageDrmFormatModifierListCreateInfoEXT( drmFormatModifierCount_, pDrmFormatModifiers_ )
+      : drmFormatModifierCount( drmFormatModifierCount_ )
+      , pDrmFormatModifiers( pDrmFormatModifiers_ )
     {}
 
+    vk::ImageDrmFormatModifierListCreateInfoEXT & operator=( vk::ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierListCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageDrmFormatModifierListCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageDrmFormatModifierListCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageDrmFormatModifierListCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -39100,52 +36590,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageDrmFormatModifierListCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
+    const void* pNext = nullptr;
+    uint32_t drmFormatModifierCount;
+    const uint64_t* pDrmFormatModifiers;
   };
   static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageDrmFormatModifierListCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ImageDrmFormatModifierPropertiesEXT
-    {
-    protected:
-      ImageDrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this) = rhs;
-      }
-
-      ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImageDrmFormatModifierPropertiesEXT
   {
-    ImageDrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::ImageDrmFormatModifierPropertiesEXT()
+    ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : drmFormatModifier( drmFormatModifier_ )
     {}
 
+    vk::ImageDrmFormatModifierPropertiesEXT & operator=( vk::ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageDrmFormatModifierPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageDrmFormatModifierPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageDrmFormatModifierPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -39171,57 +36644,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageDrmFormatModifierPropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
+    void* pNext = nullptr;
+    uint64_t drmFormatModifier;
   };
   static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageDrmFormatModifierPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ImageFormatListCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
-                                                         const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : viewFormatCount( viewFormatCount_ )
-        , pViewFormats( pViewFormats_ )
-      {}
-
-      ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this) = rhs;
-      }
-
-      ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct ImageFormatListCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
                                                        const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageFormatListCreateInfoKHR( viewFormatCount_, pViewFormats_ )
+      : viewFormatCount( viewFormatCount_ )
+      , pViewFormats( pViewFormats_ )
     {}
 
+    vk::ImageFormatListCreateInfoKHR & operator=( vk::ImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageFormatListCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageFormatListCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageFormatListCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageFormatListCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -39266,52 +36718,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageFormatListCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
+    const void* pNext = nullptr;
+    uint32_t viewFormatCount;
+    const vk::Format* pViewFormats;
   };
   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
   {
-    struct ImageFormatProperties2
-    {
-    protected:
-      ImageFormatProperties2() VULKAN_HPP_NOEXCEPT
-      {}
-
-      ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageFormatProperties2*>(this) = rhs;
-      }
-
-      ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    ImageFormatProperties2() VULKAN_HPP_NOEXCEPT
-      : layout::ImageFormatProperties2()
+    ImageFormatProperties2( vk::ImageFormatProperties imageFormatProperties_ = vk::ImageFormatProperties() ) VULKAN_HPP_NOEXCEPT
+      : imageFormatProperties( imageFormatProperties_ )
     {}
 
+    vk::ImageFormatProperties2 & operator=( vk::ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageFormatProperties2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageFormatProperties2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageFormatProperties2::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageFormatProperties2 const *>(&rhs);
       return *this;
     }
 
@@ -39337,8 +36772,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageFormatProperties2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageFormatProperties2;
+    void* pNext = nullptr;
+    vk::ImageFormatProperties imageFormatProperties;
   };
   static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageFormatProperties2>::value, "struct wrapper is not a standard layout!" );
@@ -39359,12 +36796,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageSubresourceRange*>(this) = rhs;
+      *this = rhs;
     }
 
     ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageSubresourceRange*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ImageSubresourceRange const *>(&rhs);
       return *this;
     }
 
@@ -39432,56 +36869,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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() ) VULKAN_HPP_NOEXCEPT
-        : srcAccessMask( srcAccessMask_ )
-        , dstAccessMask( dstAccessMask_ )
-        , oldLayout( oldLayout_ )
-        , newLayout( newLayout_ )
-        , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
-        , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
-        , image( image_ )
-        , subresourceRange( subresourceRange_ )
-      {}
-
-      ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageMemoryBarrier*>(this) = rhs;
-      }
-
-      ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ImageMemoryBarrier
+  struct ImageMemoryBarrier
   {
     VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
                                              vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
@@ -39491,16 +36879,30 @@ namespace VULKAN_HPP_NAMESPACE
                                              uint32_t dstQueueFamilyIndex_ = 0,
                                              vk::Image image_ = vk::Image(),
                                              vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageMemoryBarrier( srcAccessMask_, dstAccessMask_, oldLayout_, newLayout_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, image_, subresourceRange_ )
+      : srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
+      , oldLayout( oldLayout_ )
+      , newLayout( newLayout_ )
+      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+      , image( image_ )
+      , subresourceRange( subresourceRange_ )
     {}
 
+    vk::ImageMemoryBarrier & operator=( vk::ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageMemoryBarrier ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageMemoryBarrier( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageMemoryBarrier::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageMemoryBarrier const *>(&rhs);
       return *this;
     }
 
@@ -39587,53 +36989,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageMemoryBarrier::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT
-        : image( image_ )
-      {}
-
-      ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this) = rhs;
-      }
-
-      ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct ImageMemoryRequirementsInfo2
   {
     VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageMemoryRequirementsInfo2( image_ )
+      : image( image_ )
     {}
 
+    vk::ImageMemoryRequirementsInfo2 & operator=( vk::ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageMemoryRequirementsInfo2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageMemoryRequirementsInfo2::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageMemoryRequirementsInfo2 const *>(&rhs);
       return *this;
     }
 
@@ -39671,59 +37061,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageMemoryRequirementsInfo2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageMemoryRequirementsInfo2;
+    const void* pNext = nullptr;
+    vk::Image image;
   };
   static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_FUCHSIA
 
-  namespace layout
-  {
-    struct ImagePipeSurfaceCreateInfoFUCHSIA
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(),
-                                                              zx_handle_t imagePipeHandle_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , imagePipeHandle( imagePipeHandle_ )
-      {}
-
-      ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this) = rhs;
-      }
-
-      ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImagePipeSurfaceCreateInfoFUCHSIA
   {
     VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(),
                                                             zx_handle_t imagePipeHandle_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ImagePipeSurfaceCreateInfoFUCHSIA( flags_, imagePipeHandle_ )
+      : flags( flags_ )
+      , imagePipeHandle( imagePipeHandle_ )
     {}
 
+    vk::ImagePipeSurfaceCreateInfoFUCHSIA & operator=( vk::ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImagePipeSurfaceCreateInfoFUCHSIA ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImagePipeSurfaceCreateInfoFUCHSIA( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImagePipeSurfaceCreateInfoFUCHSIA::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImagePipeSurfaceCreateInfoFUCHSIA const *>(&rhs);
       return *this;
     }
 
@@ -39768,54 +37137,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImagePipeSurfaceCreateInfoFUCHSIA::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
+    const void* pNext = nullptr;
+    vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags;
+    zx_handle_t imagePipeHandle;
   };
   static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImagePipeSurfaceCreateInfoFUCHSIA>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
 
-  namespace layout
-  {
-    struct ImagePlaneMemoryRequirementsInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT
-        : planeAspect( planeAspect_ )
-      {}
-
-      ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this) = rhs;
-      }
-
-      ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImagePlaneMemoryRequirementsInfo
   {
     VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT
-      : layout::ImagePlaneMemoryRequirementsInfo( planeAspect_ )
+      : planeAspect( planeAspect_ )
     {}
 
+    vk::ImagePlaneMemoryRequirementsInfo & operator=( vk::ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImagePlaneMemoryRequirementsInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImagePlaneMemoryRequirementsInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImagePlaneMemoryRequirementsInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImagePlaneMemoryRequirementsInfo const *>(&rhs);
       return *this;
     }
 
@@ -39853,8 +37204,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImagePlaneMemoryRequirementsInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
+    const void* pNext = nullptr;
+    vk::ImageAspectFlagBits planeAspect;
   };
   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!" );
@@ -39875,12 +37228,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ImageResolve( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageResolve*>(this) = rhs;
+      *this = rhs;
     }
 
     ImageResolve& operator=( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkImageResolve*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ImageResolve const *>(&rhs);
       return *this;
     }
 
@@ -39948,47 +37301,26 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT
-        : image( image_ )
-      {}
-
-      ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this) = rhs;
-      }
-
-      ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ImageSparseMemoryRequirementsInfo2
+  struct ImageSparseMemoryRequirementsInfo2
   {
     VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageSparseMemoryRequirementsInfo2( image_ )
+      : image( image_ )
     {}
 
+    vk::ImageSparseMemoryRequirementsInfo2 & operator=( vk::ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageSparseMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageSparseMemoryRequirementsInfo2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageSparseMemoryRequirementsInfo2::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageSparseMemoryRequirementsInfo2 const *>(&rhs);
       return *this;
     }
 
@@ -40026,53 +37358,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageSparseMemoryRequirementsInfo2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2;
+    const void* pNext = nullptr;
+    vk::Image image;
   };
   static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageSparseMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ImageStencilUsageCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT
-        : stencilUsage( stencilUsage_ )
-      {}
-
-      ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>(this) = rhs;
-      }
-
-      ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImageStencilUsageCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageStencilUsageCreateInfoEXT( stencilUsage_ )
+      : stencilUsage( stencilUsage_ )
     {}
 
+    vk::ImageStencilUsageCreateInfoEXT & operator=( vk::ImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageStencilUsageCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageStencilUsageCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageStencilUsageCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageStencilUsageCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -40110,53 +37423,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageStencilUsageCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::ImageUsageFlags stencilUsage;
   };
   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:
-      VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT
-        : swapchain( swapchain_ )
-      {}
-
-      ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this) = rhs;
-      }
-
-      ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ImageSwapchainCreateInfoKHR
+  struct ImageSwapchainCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageSwapchainCreateInfoKHR( swapchain_ )
+      : swapchain( swapchain_ )
     {}
 
+    vk::ImageSwapchainCreateInfoKHR & operator=( vk::ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageSwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageSwapchainCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageSwapchainCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageSwapchainCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -40194,53 +37488,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageSwapchainCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR;
+    const void* pNext = nullptr;
+    vk::SwapchainKHR swapchain;
   };
   static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageSwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ImageViewASTCDecodeModeEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined ) VULKAN_HPP_NOEXCEPT
-        : decodeMode( decodeMode_ )
-      {}
-
-      ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this) = rhs;
-      }
-
-      ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImageViewASTCDecodeModeEXT
   {
     VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageViewASTCDecodeModeEXT( decodeMode_ )
+      : decodeMode( decodeMode_ )
     {}
 
+    vk::ImageViewASTCDecodeModeEXT & operator=( vk::ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewASTCDecodeModeEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageViewASTCDecodeModeEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageViewASTCDecodeModeEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageViewASTCDecodeModeEXT const *>(&rhs);
       return *this;
     }
 
@@ -40278,56 +37553,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageViewASTCDecodeModeEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
+    const void* pNext = nullptr;
+    vk::Format decodeMode;
   };
   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:
-      VULKAN_HPP_CONSTEXPR 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() ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , image( image_ )
-        , viewType( viewType_ )
-        , format( format_ )
-        , components( components_ )
-        , subresourceRange( subresourceRange_ )
-      {}
-
-      ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageViewCreateInfo*>(this) = rhs;
-      }
-
-      ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ImageViewCreateInfo
+  struct ImageViewCreateInfo
   {
     VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(),
                                               vk::Image image_ = vk::Image(),
@@ -40335,16 +37569,28 @@ namespace VULKAN_HPP_NAMESPACE
                                               vk::Format format_ = vk::Format::eUndefined,
                                               vk::ComponentMapping components_ = vk::ComponentMapping(),
                                               vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageViewCreateInfo( flags_, image_, viewType_, format_, components_, subresourceRange_ )
+      : flags( flags_ )
+      , image( image_ )
+      , viewType( viewType_ )
+      , format( format_ )
+      , components( components_ )
+      , subresourceRange( subresourceRange_ )
     {}
 
+    vk::ImageViewCreateInfo & operator=( vk::ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageViewCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageViewCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageViewCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -40417,61 +37663,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageViewCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(),
-                                                   vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
-                                                   vk::Sampler sampler_ = vk::Sampler() ) VULKAN_HPP_NOEXCEPT
-        : imageView( imageView_ )
-        , descriptorType( descriptorType_ )
-        , sampler( sampler_ )
-      {}
-
-      ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageViewHandleInfoNVX*>(this) = rhs;
-      }
-
-      ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ImageViewHandleInfoNVX
+  struct ImageViewHandleInfoNVX
   {
     VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(),
                                                  vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
                                                  vk::Sampler sampler_ = vk::Sampler() ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageViewHandleInfoNVX( imageView_, descriptorType_, sampler_ )
+      : imageView( imageView_ )
+      , descriptorType( descriptorType_ )
+      , sampler( sampler_ )
     {}
 
+    vk::ImageViewHandleInfoNVX & operator=( vk::ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewHandleInfoNVX ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageViewHandleInfoNVX( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageViewHandleInfoNVX::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageViewHandleInfoNVX const *>(&rhs);
       return *this;
     }
 
@@ -40523,53 +37751,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageViewHandleInfoNVX::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageViewHandleInfoNVX;
+    const void* pNext = nullptr;
+    vk::ImageView imageView;
+    vk::DescriptorType descriptorType;
+    vk::Sampler sampler;
   };
   static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageViewHandleInfoNVX>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ImageViewUsageCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT
-        : usage( usage_ )
-      {}
-
-      ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImageViewUsageCreateInfo*>(this) = rhs;
-      }
-
-      ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ImageViewUsageCreateInfo
+  struct ImageViewUsageCreateInfo
   {
     VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageViewUsageCreateInfo( usage_ )
+      : usage( usage_ )
     {}
 
+    vk::ImageViewUsageCreateInfo & operator=( vk::ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewUsageCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImageViewUsageCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImageViewUsageCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImageViewUsageCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -40607,55 +37818,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImageViewUsageCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImageViewUsageCreateInfo;
+    const void* pNext = nullptr;
+    vk::ImageUsageFlags usage;
   };
   static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImageViewUsageCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
-  namespace layout
-  {
-    struct ImportAndroidHardwareBufferInfoANDROID
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : buffer( buffer_ )
-      {}
-
-      ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this) = rhs;
-      }
-
-      ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImportAndroidHardwareBufferInfoANDROID
   {
     VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportAndroidHardwareBufferInfoANDROID( buffer_ )
+      : buffer( buffer_ )
     {}
 
+    vk::ImportAndroidHardwareBufferInfoANDROID & operator=( vk::ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportAndroidHardwareBufferInfoANDROID ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportAndroidHardwareBufferInfoANDROID( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportAndroidHardwareBufferInfoANDROID::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportAndroidHardwareBufferInfoANDROID const *>(&rhs);
       return *this;
     }
 
@@ -40693,66 +37885,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportAndroidHardwareBufferInfoANDROID::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
+    const void* pNext = nullptr;
+    struct AHardwareBuffer* buffer;
   };
   static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportAndroidHardwareBufferInfoANDROID>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  namespace layout
-  {
-    struct ImportFenceFdInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(),
-                                                 vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
-                                                 vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
-                                                 int fd_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : fence( fence_ )
-        , flags( flags_ )
-        , handleType( handleType_ )
-        , fd( fd_ )
-      {}
-
-      ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportFenceFdInfoKHR*>(this) = rhs;
-      }
-
-      ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImportFenceFdInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(),
                                                vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
                                                vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
                                                int fd_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportFenceFdInfoKHR( fence_, flags_, handleType_, fd_ )
+      : fence( fence_ )
+      , flags( flags_ )
+      , handleType( handleType_ )
+      , fd( fd_ )
     {}
 
+    vk::ImportFenceFdInfoKHR & operator=( vk::ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportFenceFdInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportFenceFdInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportFenceFdInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportFenceFdInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -40811,71 +37978,47 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportFenceFdInfoKHR::sType;
+  public:
+    const 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 ), "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
 
-  namespace layout
-  {
-    struct ImportFenceWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
-                                                          vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
-                                                          vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
-                                                          HANDLE handle_ = 0,
-                                                          LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : fence( fence_ )
-        , flags( flags_ )
-        , handleType( handleType_ )
-        , handle( handle_ )
-        , name( name_ )
-      {}
-
-      ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImportFenceWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
                                                         vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
                                                         vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
                                                         HANDLE handle_ = 0,
                                                         LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportFenceWin32HandleInfoKHR( fence_, flags_, handleType_, handle_, name_ )
+      : fence( fence_ )
+      , flags( flags_ )
+      , handleType( handleType_ )
+      , handle( handle_ )
+      , name( name_ )
     {}
 
+    vk::ImportFenceWin32HandleInfoKHR & operator=( vk::ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportFenceWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportFenceWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportFenceWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportFenceWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -40941,58 +38084,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportFenceWin32HandleInfoKHR::sType;
+  public:
+    const 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 ), "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*/
 
-  namespace layout
-  {
-    struct ImportMemoryFdInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
-                                                  int fd_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : handleType( handleType_ )
-        , fd( fd_ )
-      {}
-
-      ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this) = rhs;
-      }
-
-      ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImportMemoryFdInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                                                 int fd_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportMemoryFdInfoKHR( handleType_, fd_ )
+      : handleType( handleType_ )
+      , fd( fd_ )
     {}
 
+    vk::ImportMemoryFdInfoKHR & operator=( vk::ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryFdInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportMemoryFdInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportMemoryFdInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportMemoryFdInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -41037,57 +38163,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportMemoryFdInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImportMemoryFdInfoKHR;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlagBits handleType;
+    int fd;
   };
   static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportMemoryFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ImportMemoryHostPointerInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
-                                                           void* pHostPointer_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : handleType( handleType_ )
-        , pHostPointer( pHostPointer_ )
-      {}
-
-      ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this) = rhs;
-      }
-
-      ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ImportMemoryHostPointerInfoEXT
+  struct ImportMemoryHostPointerInfoEXT
   {
     VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                                                          void* pHostPointer_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportMemoryHostPointerInfoEXT( handleType_, pHostPointer_ )
+      : handleType( handleType_ )
+      , pHostPointer( pHostPointer_ )
     {}
 
+    vk::ImportMemoryHostPointerInfoEXT & operator=( vk::ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryHostPointerInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportMemoryHostPointerInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportMemoryHostPointerInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportMemoryHostPointerInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -41132,63 +38238,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportMemoryHostPointerInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlagBits handleType;
+    void* pHostPointer;
   };
   static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportMemoryHostPointerInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct ImportMemoryWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
-                                                           HANDLE handle_ = 0,
-                                                           LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : handleType( handleType_ )
-        , handle( handle_ )
-        , name( name_ )
-      {}
-
-      ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImportMemoryWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
                                                          HANDLE handle_ = 0,
                                                          LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportMemoryWin32HandleInfoKHR( handleType_, handle_, name_ )
+      : handleType( handleType_ )
+      , handle( handle_ )
+      , name( name_ )
     {}
 
+    vk::ImportMemoryWin32HandleInfoKHR & operator=( vk::ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportMemoryWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportMemoryWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportMemoryWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -41240,8 +38324,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportMemoryWin32HandleInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
   };
   static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -41249,51 +38337,28 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct ImportMemoryWin32HandleInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(),
-                                                          HANDLE handle_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : handleType( handleType_ )
-        , handle( handle_ )
-      {}
-
-      ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this) = rhs;
-      }
-
-      ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImportMemoryWin32HandleInfoNV
   {
     VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(),
                                                         HANDLE handle_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportMemoryWin32HandleInfoNV( handleType_, handle_ )
+      : handleType( handleType_ )
+      , handle( handle_ )
     {}
 
+    vk::ImportMemoryWin32HandleInfoNV & operator=( vk::ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryWin32HandleInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportMemoryWin32HandleInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportMemoryWin32HandleInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportMemoryWin32HandleInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -41338,66 +38403,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportMemoryWin32HandleInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlagsNV handleType;
+    HANDLE handle;
   };
   static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportMemoryWin32HandleInfoNV>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  namespace layout
-  {
-    struct ImportSemaphoreFdInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
-                                                     vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
-                                                     vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
-                                                     int fd_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : semaphore( semaphore_ )
-        , flags( flags_ )
-        , handleType( handleType_ )
-        , fd( fd_ )
-      {}
-
-      ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this) = rhs;
-      }
-
-      ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImportSemaphoreFdInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
                                                    vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
                                                    vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
                                                    int fd_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportSemaphoreFdInfoKHR( semaphore_, flags_, handleType_, fd_ )
+      : semaphore( semaphore_ )
+      , flags( flags_ )
+      , handleType( handleType_ )
+      , fd( fd_ )
     {}
 
+    vk::ImportSemaphoreFdInfoKHR & operator=( vk::ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportSemaphoreFdInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportSemaphoreFdInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportSemaphoreFdInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportSemaphoreFdInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -41456,71 +38497,47 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportSemaphoreFdInfoKHR::sType;
+  public:
+    const 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 ), "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
 
-  namespace layout
-  {
-    struct ImportSemaphoreWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
-                                                              vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
-                                                              vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
-                                                              HANDLE handle_ = 0,
-                                                              LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : semaphore( semaphore_ )
-        , flags( flags_ )
-        , handleType( handleType_ )
-        , handle( handle_ )
-        , name( name_ )
-      {}
-
-      ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ImportSemaphoreWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
                                                             vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
                                                             vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
                                                             HANDLE handle_ = 0,
                                                             LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportSemaphoreWin32HandleInfoKHR( semaphore_, flags_, handleType_, handle_, name_ )
+      : semaphore( semaphore_ )
+      , flags( flags_ )
+      , handleType( handleType_ )
+      , handle( handle_ )
+      , name( name_ )
     {}
 
+    vk::ImportSemaphoreWin32HandleInfoKHR & operator=( vk::ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportSemaphoreWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ImportSemaphoreWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ImportSemaphoreWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::ImportSemaphoreWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -41586,8 +38603,14 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ImportSemaphoreWin32HandleInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ImportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -41607,12 +38630,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this) = rhs;
+      *this = rhs;
     }
 
     IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this) = rhs;
+      *this = *reinterpret_cast<vk::IndirectCommandsLayoutTokenNVX const *>(&rhs);
       return *this;
     }
 
@@ -41672,59 +38695,32 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
-                                                                vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(),
-                                                                uint32_t tokenCount_ = 0,
-                                                                const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : pipelineBindPoint( pipelineBindPoint_ )
-        , flags( flags_ )
-        , tokenCount( tokenCount_ )
-        , pTokens( pTokens_ )
-      {}
-
-      IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this) = rhs;
-      }
-
-      IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct IndirectCommandsLayoutCreateInfoNVX
   {
     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
                                                               vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(),
                                                               uint32_t tokenCount_ = 0,
                                                               const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::IndirectCommandsLayoutCreateInfoNVX( pipelineBindPoint_, flags_, tokenCount_, pTokens_ )
+      : pipelineBindPoint( pipelineBindPoint_ )
+      , flags( flags_ )
+      , tokenCount( tokenCount_ )
+      , pTokens( pTokens_ )
     {}
 
+    vk::IndirectCommandsLayoutCreateInfoNVX & operator=( vk::IndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::IndirectCommandsLayoutCreateInfoNVX ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::IndirectCommandsLayoutCreateInfoNVX( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::IndirectCommandsLayoutCreateInfoNVX::operator=(rhs);
+      *this = *reinterpret_cast<vk::IndirectCommandsLayoutCreateInfoNVX const *>(&rhs);
       return *this;
     }
 
@@ -41783,53 +38779,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::IndirectCommandsLayoutCreateInfoNVX::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<IndirectCommandsLayoutCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct InitializePerformanceApiInfoINTEL
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : pUserData( pUserData_ )
-      {}
-
-      InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(this) = rhs;
-      }
-
-      InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct InitializePerformanceApiInfoINTEL
   {
     VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::InitializePerformanceApiInfoINTEL( pUserData_ )
+      : pUserData( pUserData_ )
     {}
 
+    vk::InitializePerformanceApiInfoINTEL & operator=( vk::InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::InitializePerformanceApiInfoINTEL ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::InitializePerformanceApiInfoINTEL( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::InitializePerformanceApiInfoINTEL::operator=(rhs);
+      *this = *reinterpret_cast<vk::InitializePerformanceApiInfoINTEL const *>(&rhs);
       return *this;
     }
 
@@ -41867,8 +38847,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::InitializePerformanceApiInfoINTEL::sType;
+  public:
+    const vk::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL;
+    const void* pNext = nullptr;
+    void* pUserData;
   };
   static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<InitializePerformanceApiInfoINTEL>::value, "struct wrapper is not a standard layout!" );
@@ -41885,12 +38867,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkInputAttachmentAspectReference*>(this) = rhs;
+      *this = rhs;
     }
 
     InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkInputAttachmentAspectReference*>(this) = rhs;
+      *this = *reinterpret_cast<vk::InputAttachmentAspectReference const *>(&rhs);
       return *this;
     }
 
@@ -41942,50 +38924,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , pApplicationInfo( pApplicationInfo_ )
-        , enabledLayerCount( enabledLayerCount_ )
-        , ppEnabledLayerNames( ppEnabledLayerNames_ )
-        , enabledExtensionCount( enabledExtensionCount_ )
-        , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
-      {}
-
-      InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkInstanceCreateInfo*>(this) = rhs;
-      }
-
-      InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::InstanceCreateInfo
+  struct InstanceCreateInfo
   {
     VULKAN_HPP_CONSTEXPR InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(),
                                              const vk::ApplicationInfo* pApplicationInfo_ = nullptr,
@@ -41993,16 +38932,28 @@ namespace VULKAN_HPP_NAMESPACE
                                              const char* const* ppEnabledLayerNames_ = nullptr,
                                              uint32_t enabledExtensionCount_ = 0,
                                              const char* const* ppEnabledExtensionNames_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::InstanceCreateInfo( flags_, pApplicationInfo_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_ )
+      : flags( flags_ )
+      , pApplicationInfo( pApplicationInfo_ )
+      , enabledLayerCount( enabledLayerCount_ )
+      , ppEnabledLayerNames( ppEnabledLayerNames_ )
+      , enabledExtensionCount( enabledExtensionCount_ )
+      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
     {}
 
+    vk::InstanceCreateInfo & operator=( vk::InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::InstanceCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::InstanceCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::InstanceCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::InstanceCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -42075,25 +39026,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::InstanceCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<InstanceCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
   struct LayerProperties
   {
-    LayerProperties() VULKAN_HPP_NOEXCEPT
-    {}
+    LayerProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& layerName_ = { { 0 } },
+                     uint32_t specVersion_ = 0,
+                     uint32_t implementationVersion_ = 0,
+                     std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+      : layerName{}
+      , specVersion( specVersion_ )
+      , implementationVersion( implementationVersion_ )
+      , description{}
+    {
+      vk::ConstExpressionArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE,VK_MAX_EXTENSION_NAME_SIZE>::copy( layerName, layerName_ );
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+    }
 
     LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkLayerProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     LayerProperties& operator=( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkLayerProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::LayerProperties const *>(&rhs);
       return *this;
     }
 
@@ -42131,51 +39099,28 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_MACOS_MVK
 
-  namespace layout
-  {
-    struct MacOSSurfaceCreateInfoMVK
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(),
-                                                      const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , pView( pView_ )
-      {}
-
-      MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this) = rhs;
-      }
-
-      MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MacOSSurfaceCreateInfoMVK
   {
     VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(),
                                                     const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::MacOSSurfaceCreateInfoMVK( flags_, pView_ )
+      : flags( flags_ )
+      , pView( pView_ )
     {}
 
+    vk::MacOSSurfaceCreateInfoMVK & operator=( vk::MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MacOSSurfaceCreateInfoMVK ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MacOSSurfaceCreateInfoMVK( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MacOSSurfaceCreateInfoMVK::operator=(rhs);
+      *this = *reinterpret_cast<vk::MacOSSurfaceCreateInfoMVK const *>(&rhs);
       return *this;
     }
 
@@ -42220,62 +39165,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MacOSSurfaceCreateInfoMVK::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
+    const void* pNext = nullptr;
+    vk::MacOSSurfaceCreateFlagsMVK flags;
+    const void* pView;
   };
   static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MacOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
 
-  namespace layout
-  {
-    struct MappedMemoryRange
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(),
-                                              vk::DeviceSize offset_ = 0,
-                                              vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : memory( memory_ )
-        , offset( offset_ )
-        , size( size_ )
-      {}
-
-      MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMappedMemoryRange*>(this) = rhs;
-      }
-
-      MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MappedMemoryRange
   {
     VULKAN_HPP_CONSTEXPR MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(),
                                             vk::DeviceSize offset_ = 0,
                                             vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::MappedMemoryRange( memory_, offset_, size_ )
+      : memory( memory_ )
+      , offset( offset_ )
+      , size( size_ )
     {}
 
+    vk::MappedMemoryRange & operator=( vk::MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MappedMemoryRange ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MappedMemoryRange( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MappedMemoryRange::operator=(rhs);
+      *this = *reinterpret_cast<vk::MappedMemoryRange const *>(&rhs);
       return *this;
     }
 
@@ -42327,57 +39250,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MappedMemoryRange::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMappedMemoryRange;
+    const void* pNext = nullptr;
+    vk::DeviceMemory memory;
+    vk::DeviceSize offset;
+    vk::DeviceSize size;
   };
   static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MappedMemoryRange>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct MemoryAllocateFlagsInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(),
-                                                    uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , deviceMask( deviceMask_ )
-      {}
-
-      MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this) = rhs;
-      }
-
-      MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::MemoryAllocateFlagsInfo
+  struct MemoryAllocateFlagsInfo
   {
     VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(),
                                                   uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryAllocateFlagsInfo( flags_, deviceMask_ )
+      : flags( flags_ )
+      , deviceMask( deviceMask_ )
     {}
 
+    vk::MemoryAllocateFlagsInfo & operator=( vk::MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryAllocateFlagsInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryAllocateFlagsInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryAllocateFlagsInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryAllocateFlagsInfo const *>(&rhs);
       return *this;
     }
 
@@ -42422,57 +39326,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryAllocateFlagsInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
+    const void* pNext = nullptr;
+    vk::MemoryAllocateFlags flags;
+    uint32_t deviceMask;
   };
   static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryAllocateFlagsInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct MemoryAllocateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0,
-                                               uint32_t memoryTypeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : allocationSize( allocationSize_ )
-        , memoryTypeIndex( memoryTypeIndex_ )
-      {}
-
-      MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryAllocateInfo*>(this) = rhs;
-      }
-
-      MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryAllocateInfo*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct MemoryAllocateInfo
   {
     VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0,
                                              uint32_t memoryTypeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryAllocateInfo( allocationSize_, memoryTypeIndex_ )
+      : allocationSize( allocationSize_ )
+      , memoryTypeIndex( memoryTypeIndex_ )
     {}
 
+    vk::MemoryAllocateInfo & operator=( vk::MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryAllocateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryAllocateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryAllocateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryAllocateInfo const *>(&rhs);
       return *this;
     }
 
@@ -42517,57 +39401,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryAllocateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryAllocateInfo;
+    const void* pNext = nullptr;
+    vk::DeviceSize allocationSize;
+    uint32_t memoryTypeIndex;
   };
   static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct MemoryBarrier
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
-                                          vk::AccessFlags dstAccessMask_ = vk::AccessFlags() ) VULKAN_HPP_NOEXCEPT
-        : srcAccessMask( srcAccessMask_ )
-        , dstAccessMask( dstAccessMask_ )
-      {}
-
-      MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryBarrier*>(this) = rhs;
-      }
-
-      MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MemoryBarrier
   {
     VULKAN_HPP_CONSTEXPR MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
                                         vk::AccessFlags dstAccessMask_ = vk::AccessFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryBarrier( srcAccessMask_, dstAccessMask_ )
+      : srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
     {}
 
+    vk::MemoryBarrier & operator=( vk::MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryBarrier ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryBarrier( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryBarrier::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryBarrier const *>(&rhs);
       return *this;
     }
 
@@ -42612,57 +39476,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryBarrier::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryBarrier;
+    const void* pNext = nullptr;
+    vk::AccessFlags srcAccessMask;
+    vk::AccessFlags dstAccessMask;
   };
   static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryBarrier>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct MemoryDedicatedAllocateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(),
-                                                        vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT
-        : image( image_ )
-        , buffer( buffer_ )
-      {}
-
-      MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this) = rhs;
-      }
-
-      MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MemoryDedicatedAllocateInfo
   {
     VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(),
                                                       vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryDedicatedAllocateInfo( image_, buffer_ )
+      : image( image_ )
+      , buffer( buffer_ )
     {}
 
+    vk::MemoryDedicatedAllocateInfo & operator=( vk::MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryDedicatedAllocateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryDedicatedAllocateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryDedicatedAllocateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryDedicatedAllocateInfo const *>(&rhs);
       return *this;
     }
 
@@ -42707,53 +39551,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryDedicatedAllocateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo;
+    const void* pNext = nullptr;
+    vk::Image image;
+    vk::Buffer buffer;
   };
   static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryDedicatedAllocateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct MemoryDedicatedRequirements
-    {
-    protected:
-      MemoryDedicatedRequirements() VULKAN_HPP_NOEXCEPT
-      {}
-
-      MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryDedicatedRequirements*>(this) = rhs;
-      }
-
-      MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::MemoryDedicatedRequirements
+  struct MemoryDedicatedRequirements
   {
-    MemoryDedicatedRequirements() VULKAN_HPP_NOEXCEPT
-      : layout::MemoryDedicatedRequirements()
+    MemoryDedicatedRequirements( vk::Bool32 prefersDedicatedAllocation_ = 0,
+                                 vk::Bool32 requiresDedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : prefersDedicatedAllocation( prefersDedicatedAllocation_ )
+      , requiresDedicatedAllocation( requiresDedicatedAllocation_ )
     {}
 
+    vk::MemoryDedicatedRequirements & operator=( vk::MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryDedicatedRequirements ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryDedicatedRequirements( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryDedicatedRequirements::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryDedicatedRequirements const *>(&rhs);
       return *this;
     }
 
@@ -42780,52 +39608,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryDedicatedRequirements::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryDedicatedRequirements;
+    void* pNext = nullptr;
+    vk::Bool32 prefersDedicatedAllocation;
+    vk::Bool32 requiresDedicatedAllocation;
   };
   static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryDedicatedRequirements>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct MemoryFdPropertiesKHR
-    {
-    protected:
-      MemoryFdPropertiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this) = rhs;
-      }
-
-      MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::MemoryFdPropertiesKHR
+  struct MemoryFdPropertiesKHR
   {
-    MemoryFdPropertiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::MemoryFdPropertiesKHR()
+    MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : memoryTypeBits( memoryTypeBits_ )
     {}
 
+    vk::MemoryFdPropertiesKHR & operator=( vk::MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryFdPropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryFdPropertiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryFdPropertiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryFdPropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -42851,55 +39662,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryFdPropertiesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryFdPropertiesKHR;
+    void* pNext = nullptr;
+    uint32_t memoryTypeBits;
   };
   static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryFdPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
-  namespace layout
-  {
-    struct MemoryGetAndroidHardwareBufferInfoANDROID
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() ) VULKAN_HPP_NOEXCEPT
-        : memory( memory_ )
-      {}
-
-      MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this) = rhs;
-      }
-
-      MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MemoryGetAndroidHardwareBufferInfoANDROID
   {
     VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryGetAndroidHardwareBufferInfoANDROID( memory_ )
+      : memory( memory_ )
     {}
 
+    vk::MemoryGetAndroidHardwareBufferInfoANDROID & operator=( vk::MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetAndroidHardwareBufferInfoANDROID ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryGetAndroidHardwareBufferInfoANDROID( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryGetAndroidHardwareBufferInfoANDROID::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryGetAndroidHardwareBufferInfoANDROID const *>(&rhs);
       return *this;
     }
 
@@ -42937,58 +39729,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryGetAndroidHardwareBufferInfoANDROID::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
+    const void* pNext = nullptr;
+    vk::DeviceMemory memory;
   };
   static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryGetAndroidHardwareBufferInfoANDROID>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
-  namespace layout
-  {
-    struct MemoryGetFdInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
-                                               vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : memory( memory_ )
-        , handleType( handleType_ )
-      {}
-
-      MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this) = rhs;
-      }
-
-      MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MemoryGetFdInfoKHR
   {
     VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
                                              vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryGetFdInfoKHR( memory_, handleType_ )
+      : memory( memory_ )
+      , handleType( handleType_ )
     {}
 
+    vk::MemoryGetFdInfoKHR & operator=( vk::MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetFdInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryGetFdInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryGetFdInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryGetFdInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -43033,59 +39804,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryGetFdInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryGetFdInfoKHR;
+    const void* pNext = nullptr;
+    vk::DeviceMemory memory;
+    vk::ExternalMemoryHandleTypeFlagBits handleType;
   };
   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
 
-  namespace layout
-  {
-    struct MemoryGetWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
-                                                        vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : memory( memory_ )
-        , handleType( handleType_ )
-      {}
-
-      MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MemoryGetWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
                                                       vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryGetWin32HandleInfoKHR( memory_, handleType_ )
+      : memory( memory_ )
+      , handleType( handleType_ )
     {}
 
+    vk::MemoryGetWin32HandleInfoKHR & operator=( vk::MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryGetWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryGetWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryGetWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -43130,8 +39881,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryGetWin32HandleInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
+    const void* pNext = nullptr;
+    vk::DeviceMemory memory;
+    vk::ExternalMemoryHandleTypeFlagBits handleType;
   };
   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!" );
@@ -43139,17 +39893,20 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct MemoryHeap
   {
-    MemoryHeap() VULKAN_HPP_NOEXCEPT
+    MemoryHeap( vk::DeviceSize size_ = 0,
+                vk::MemoryHeapFlags flags_ = vk::MemoryHeapFlags() ) VULKAN_HPP_NOEXCEPT
+      : size( size_ )
+      , flags( flags_ )
     {}
 
     MemoryHeap( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkMemoryHeap*>(this) = rhs;
+      *this = rhs;
     }
 
     MemoryHeap& operator=( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkMemoryHeap*>(this) = rhs;
+      *this = *reinterpret_cast<vk::MemoryHeap const *>(&rhs);
       return *this;
     }
 
@@ -43181,46 +39938,26 @@ namespace VULKAN_HPP_NAMESPACE
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this) = rhs;
-      }
-
-      MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::MemoryHostPointerPropertiesEXT
+  struct MemoryHostPointerPropertiesEXT
   {
-    MemoryHostPointerPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::MemoryHostPointerPropertiesEXT()
+    MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : memoryTypeBits( memoryTypeBits_ )
     {}
 
+    vk::MemoryHostPointerPropertiesEXT & operator=( vk::MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryHostPointerPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryHostPointerPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryHostPointerPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryHostPointerPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -43246,53 +39983,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryHostPointerPropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
+    void* pNext = nullptr;
+    uint32_t memoryTypeBits;
   };
   static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryHostPointerPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct MemoryPriorityAllocateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : priority( priority_ )
-      {}
-
-      MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this) = rhs;
-      }
-
-      MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::MemoryPriorityAllocateInfoEXT
+  struct MemoryPriorityAllocateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryPriorityAllocateInfoEXT( priority_ )
+      : priority( priority_ )
     {}
 
+    vk::MemoryPriorityAllocateInfoEXT & operator=( vk::MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryPriorityAllocateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryPriorityAllocateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryPriorityAllocateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryPriorityAllocateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -43330,25 +40048,32 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryPriorityAllocateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT;
+    const void* pNext = nullptr;
+    float priority;
   };
   static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryPriorityAllocateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct MemoryRequirements
   {
-    MemoryRequirements() VULKAN_HPP_NOEXCEPT
+    MemoryRequirements( vk::DeviceSize size_ = 0,
+                        vk::DeviceSize alignment_ = 0,
+                        uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : size( size_ )
+      , alignment( alignment_ )
+      , memoryTypeBits( memoryTypeBits_ )
     {}
 
     MemoryRequirements( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkMemoryRequirements*>(this) = rhs;
+      *this = rhs;
     }
 
     MemoryRequirements& operator=( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkMemoryRequirements*>(this) = rhs;
+      *this = *reinterpret_cast<vk::MemoryRequirements const *>(&rhs);
       return *this;
     }
 
@@ -43382,46 +40107,26 @@ namespace VULKAN_HPP_NAMESPACE
   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
   {
-    struct MemoryRequirements2
-    {
-    protected:
-      MemoryRequirements2() VULKAN_HPP_NOEXCEPT
-      {}
-
-      MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryRequirements2*>(this) = rhs;
-      }
-
-      MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    MemoryRequirements2() VULKAN_HPP_NOEXCEPT
-      : layout::MemoryRequirements2()
+    MemoryRequirements2( vk::MemoryRequirements memoryRequirements_ = vk::MemoryRequirements() ) VULKAN_HPP_NOEXCEPT
+      : memoryRequirements( memoryRequirements_ )
     {}
 
+    vk::MemoryRequirements2 & operator=( vk::MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryRequirements2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryRequirements2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryRequirements2::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryRequirements2 const *>(&rhs);
       return *this;
     }
 
@@ -43447,25 +40152,30 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryRequirements2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryRequirements2;
+    void* pNext = nullptr;
+    vk::MemoryRequirements memoryRequirements;
   };
   static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryRequirements2>::value, "struct wrapper is not a standard layout!" );
 
   struct MemoryType
   {
-    MemoryType() VULKAN_HPP_NOEXCEPT
+    MemoryType( vk::MemoryPropertyFlags propertyFlags_ = vk::MemoryPropertyFlags(),
+                uint32_t heapIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : propertyFlags( propertyFlags_ )
+      , heapIndex( heapIndex_ )
     {}
 
     MemoryType( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkMemoryType*>(this) = rhs;
+      *this = rhs;
     }
 
     MemoryType& operator=( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkMemoryType*>(this) = rhs;
+      *this = *reinterpret_cast<vk::MemoryType const *>(&rhs);
       return *this;
     }
 
@@ -43499,46 +40209,26 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct MemoryWin32HandlePropertiesKHR
-    {
-    protected:
-      MemoryWin32HandlePropertiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this) = rhs;
-      }
-
-      MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MemoryWin32HandlePropertiesKHR
   {
-    MemoryWin32HandlePropertiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::MemoryWin32HandlePropertiesKHR()
+    MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : memoryTypeBits( memoryTypeBits_ )
     {}
 
+    vk::MemoryWin32HandlePropertiesKHR & operator=( vk::MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryWin32HandlePropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MemoryWin32HandlePropertiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MemoryWin32HandlePropertiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::MemoryWin32HandlePropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -43564,8 +40254,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MemoryWin32HandlePropertiesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
+    void* pNext = nullptr;
+    uint32_t memoryTypeBits;
   };
   static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MemoryWin32HandlePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
@@ -43573,51 +40265,28 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_METAL_EXT
 
-  namespace layout
-  {
-    struct MetalSurfaceCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(),
-                                                      const CAMetalLayer* pLayer_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , pLayer( pLayer_ )
-      {}
-
-      MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>(this) = rhs;
-      }
-
-      MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct MetalSurfaceCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(),
                                                     const CAMetalLayer* pLayer_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::MetalSurfaceCreateInfoEXT( flags_, pLayer_ )
+      : flags( flags_ )
+      , pLayer( pLayer_ )
     {}
 
+    vk::MetalSurfaceCreateInfoEXT & operator=( vk::MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MetalSurfaceCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MetalSurfaceCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MetalSurfaceCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::MetalSurfaceCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -43662,53 +40331,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MetalSurfaceCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::MetalSurfaceCreateFlagsEXT flags;
+    const CAMetalLayer* pLayer;
   };
   static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MetalSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
-  namespace layout
+  struct MultisamplePropertiesEXT
   {
-    struct MultisamplePropertiesEXT
-    {
-    protected:
-      MultisamplePropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkMultisamplePropertiesEXT*>(this) = rhs;
-      }
-
-      MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    MultisamplePropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::MultisamplePropertiesEXT()
+    MultisamplePropertiesEXT( vk::Extent2D maxSampleLocationGridSize_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT
+      : maxSampleLocationGridSize( maxSampleLocationGridSize_ )
     {}
 
+    vk::MultisamplePropertiesEXT & operator=( vk::MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::MultisamplePropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::MultisamplePropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::MultisamplePropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::MultisamplePropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -43734,65 +40386,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::MultisamplePropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eMultisamplePropertiesEXT;
+    void* pNext = nullptr;
+    vk::Extent2D maxSampleLocationGridSize;
   };
   static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<MultisamplePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ObjectTableCreateInfoNVX
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : objectCount( objectCount_ )
-        , pObjectEntryTypes( pObjectEntryTypes_ )
-        , pObjectEntryCounts( pObjectEntryCounts_ )
-        , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
-        , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
-        , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
-        , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
-        , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
-        , maxPipelineLayouts( maxPipelineLayouts_ )
-      {}
-
-      ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this) = rhs;
-      }
-
-      ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ObjectTableCreateInfoNVX
   {
     VULKAN_HPP_CONSTEXPR ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0,
                                                    const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
@@ -43803,16 +40405,31 @@ namespace VULKAN_HPP_NAMESPACE
                                                    uint32_t maxStorageImagesPerDescriptor_ = 0,
                                                    uint32_t maxSampledImagesPerDescriptor_ = 0,
                                                    uint32_t maxPipelineLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ObjectTableCreateInfoNVX( objectCount_, pObjectEntryTypes_, pObjectEntryCounts_, pObjectEntryUsageFlags_, maxUniformBuffersPerDescriptor_, maxStorageBuffersPerDescriptor_, maxStorageImagesPerDescriptor_, maxSampledImagesPerDescriptor_, maxPipelineLayouts_ )
+      : objectCount( objectCount_ )
+      , pObjectEntryTypes( pObjectEntryTypes_ )
+      , pObjectEntryCounts( pObjectEntryCounts_ )
+      , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
+      , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
+      , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
+      , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
+      , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
+      , maxPipelineLayouts( maxPipelineLayouts_ )
     {}
 
+    vk::ObjectTableCreateInfoNVX & operator=( vk::ObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ObjectTableCreateInfoNVX ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ObjectTableCreateInfoNVX( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ObjectTableCreateInfoNVX::operator=(rhs);
+      *this = *reinterpret_cast<vk::ObjectTableCreateInfoNVX const *>(&rhs);
       return *this;
     }
 
@@ -43906,8 +40523,18 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ObjectTableCreateInfoNVX::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ObjectTableCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
@@ -43922,12 +40549,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTableEntryNVX*>(this) = rhs;
+      *this = rhs;
     }
 
     ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTableEntryNVX*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ObjectTableEntryNVX const *>(&rhs);
       return *this;
     }
 
@@ -43994,12 +40621,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this) = rhs;
+      *this = rhs;
     }
 
     ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ObjectTableDescriptorSetEntryNVX const *>(&rhs);
       return *this;
     }
 
@@ -44082,12 +40709,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this) = rhs;
+      *this = rhs;
     }
 
     ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ObjectTableIndexBufferEntryNVX const *>(&rhs);
       return *this;
     }
 
@@ -44166,12 +40793,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this) = rhs;
+      *this = rhs;
     }
 
     ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ObjectTablePipelineEntryNVX const *>(&rhs);
       return *this;
     }
 
@@ -44246,12 +40873,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this) = rhs;
+      *this = rhs;
     }
 
     ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ObjectTablePushConstantEntryNVX const *>(&rhs);
       return *this;
     }
 
@@ -44330,12 +40957,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this) = rhs;
+      *this = rhs;
     }
 
     ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ObjectTableVertexBufferEntryNVX const *>(&rhs);
       return *this;
     }
 
@@ -44389,17 +41016,26 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PastPresentationTimingGOOGLE
   {
-    PastPresentationTimingGOOGLE() VULKAN_HPP_NOEXCEPT
+    PastPresentationTimingGOOGLE( uint32_t presentID_ = 0,
+                                  uint64_t desiredPresentTime_ = 0,
+                                  uint64_t actualPresentTime_ = 0,
+                                  uint64_t earliestPresentTime_ = 0,
+                                  uint64_t presentMargin_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : presentID( presentID_ )
+      , desiredPresentTime( desiredPresentTime_ )
+      , actualPresentTime( actualPresentTime_ )
+      , earliestPresentTime( earliestPresentTime_ )
+      , presentMargin( presentMargin_ )
     {}
 
     PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this) = rhs;
+      *this = rhs;
     }
 
     PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PastPresentationTimingGOOGLE const *>(&rhs);
       return *this;
     }
 
@@ -44437,47 +41073,26 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) VULKAN_HPP_NOEXCEPT
-        : type( type_ )
-      {}
-
-      PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this) = rhs;
-      }
-
-      PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PerformanceConfigurationAcquireInfoINTEL
   {
     VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) VULKAN_HPP_NOEXCEPT
-      : layout::PerformanceConfigurationAcquireInfoINTEL( type_ )
+      : type( type_ )
     {}
 
+    vk::PerformanceConfigurationAcquireInfoINTEL & operator=( vk::PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceConfigurationAcquireInfoINTEL ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PerformanceConfigurationAcquireInfoINTEL( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PerformanceConfigurationAcquireInfoINTEL::operator=(rhs);
+      *this = *reinterpret_cast<vk::PerformanceConfigurationAcquireInfoINTEL const *>(&rhs);
       return *this;
     }
 
@@ -44515,53 +41130,255 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PerformanceConfigurationAcquireInfoINTEL::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL;
+    const void* pNext = nullptr;
+    vk::PerformanceConfigurationTypeINTEL type;
   };
   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 PerformanceCounterDescriptionKHR
   {
-    struct PerformanceMarkerInfoINTEL
+    PerformanceCounterDescriptionKHR( vk::PerformanceCounterDescriptionFlagsKHR flags_ = vk::PerformanceCounterDescriptionFlagsKHR(),
+                                      std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+                                      std::array<char,VK_MAX_DESCRIPTION_SIZE> const& category_ = { { 0 } },
+                                      std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+      : flags( flags_ )
+      , name{}
+      , category{}
+      , description{}
     {
-    protected:
-      VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : marker( marker_ )
-      {}
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( category, category_ );
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+    }
 
-      PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this) = rhs;
-      }
+    vk::PerformanceCounterDescriptionKHR & operator=( vk::PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceCounterDescriptionKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
-      PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this) = rhs;
-        return *this;
-      }
+    PerformanceCounterDescriptionKHR( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
 
-    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!" );
-  }
+    PerformanceCounterDescriptionKHR& operator=( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<vk::PerformanceCounterDescriptionKHR const *>(&rhs);
+      return *this;
+    }
+
+    operator VkPerformanceCounterDescriptionKHR const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPerformanceCounterDescriptionKHR*>( this );
+    }
+
+    operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( this );
+    }
+
+    bool operator==( PerformanceCounterDescriptionKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+          && ( memcmp( category, rhs.category, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+          && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
+    }
+
+    bool operator!=( PerformanceCounterDescriptionKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    const vk::StructureType sType = StructureType::ePerformanceCounterDescriptionKHR;
+    const void* pNext = nullptr;
+    vk::PerformanceCounterDescriptionFlagsKHR flags;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char category[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+  };
+  static_assert( sizeof( PerformanceCounterDescriptionKHR ) == sizeof( VkPerformanceCounterDescriptionKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PerformanceCounterDescriptionKHR>::value, "struct wrapper is not a standard layout!" );
+
+  struct PerformanceCounterKHR
+  {
+    PerformanceCounterKHR( vk::PerformanceCounterUnitKHR unit_ = vk::PerformanceCounterUnitKHR::eGeneric,
+                           vk::PerformanceCounterScopeKHR scope_ = vk::PerformanceCounterScopeKHR::eVkQueryScopeCommandBuffer,
+                           vk::PerformanceCounterStorageKHR storage_ = vk::PerformanceCounterStorageKHR::eInt32,
+                           std::array<uint8_t,VK_UUID_SIZE> const& uuid_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+      : unit( unit_ )
+      , scope( scope_ )
+      , storage( storage_ )
+      , uuid{}
+    {
+      vk::ConstExpressionArrayCopy<uint8_t,VK_UUID_SIZE,VK_UUID_SIZE>::copy( uuid, uuid_ );
+    }
+
+    vk::PerformanceCounterKHR & operator=( vk::PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceCounterKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
+    PerformanceCounterKHR( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+    PerformanceCounterKHR& operator=( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<vk::PerformanceCounterKHR const *>(&rhs);
+      return *this;
+    }
+
+    operator VkPerformanceCounterKHR const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPerformanceCounterKHR*>( this );
+    }
+
+    operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPerformanceCounterKHR*>( this );
+    }
+
+    bool operator==( PerformanceCounterKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( unit == rhs.unit )
+          && ( scope == rhs.scope )
+          && ( storage == rhs.storage )
+          && ( memcmp( uuid, rhs.uuid, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 );
+    }
+
+    bool operator!=( PerformanceCounterKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    const vk::StructureType sType = StructureType::ePerformanceCounterKHR;
+    const void* pNext = nullptr;
+    vk::PerformanceCounterUnitKHR unit;
+    vk::PerformanceCounterScopeKHR scope;
+    vk::PerformanceCounterStorageKHR storage;
+    uint8_t uuid[VK_UUID_SIZE];
+  };
+  static_assert( sizeof( PerformanceCounterKHR ) == sizeof( VkPerformanceCounterKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PerformanceCounterKHR>::value, "struct wrapper is not a standard layout!" );
+
+  union PerformanceCounterResultKHR
+  {
+    PerformanceCounterResultKHR( int32_t int32_ = 0 )
+    {
+      int32 = int32_;
+    }
+
+    PerformanceCounterResultKHR( int64_t int64_ )
+    {
+      int64 = int64_;
+    }
+
+    PerformanceCounterResultKHR( uint32_t uint32_ )
+    {
+      uint32 = uint32_;
+    }
+
+    PerformanceCounterResultKHR( uint64_t uint64_ )
+    {
+      uint64 = uint64_;
+    }
+
+    PerformanceCounterResultKHR( float float32_ )
+    {
+      float32 = float32_;
+    }
+
+    PerformanceCounterResultKHR( double float64_ )
+    {
+      float64 = float64_;
+    }
+
+    PerformanceCounterResultKHR & setInt32( int32_t int32_ ) VULKAN_HPP_NOEXCEPT
+    {
+      int32 = int32_;
+      return *this;
+    }
+
+    PerformanceCounterResultKHR & setInt64( int64_t int64_ ) VULKAN_HPP_NOEXCEPT
+    {
+      int64 = int64_;
+      return *this;
+    }
+
+    PerformanceCounterResultKHR & setUint32( uint32_t uint32_ ) VULKAN_HPP_NOEXCEPT
+    {
+      uint32 = uint32_;
+      return *this;
+    }
+
+    PerformanceCounterResultKHR & setUint64( uint64_t uint64_ ) VULKAN_HPP_NOEXCEPT
+    {
+      uint64 = uint64_;
+      return *this;
+    }
+
+    PerformanceCounterResultKHR & setFloat32( float float32_ ) VULKAN_HPP_NOEXCEPT
+    {
+      float32 = float32_;
+      return *this;
+    }
+
+    PerformanceCounterResultKHR & setFloat64( double float64_ ) VULKAN_HPP_NOEXCEPT
+    {
+      float64 = float64_;
+      return *this;
+    }
+    operator VkPerformanceCounterResultKHR const&() const
+    {
+      return *reinterpret_cast<const VkPerformanceCounterResultKHR*>(this);
+    }
+
+    operator VkPerformanceCounterResultKHR &()
+    {
+      return *reinterpret_cast<VkPerformanceCounterResultKHR*>(this);
+    }
 
-  struct PerformanceMarkerInfoINTEL : public layout::PerformanceMarkerInfoINTEL
+    int32_t int32;
+    int64_t int64;
+    uint32_t uint32;
+    uint64_t uint64;
+    float float32;
+    double float64;
+  };
+
+  struct PerformanceMarkerInfoINTEL
   {
     VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PerformanceMarkerInfoINTEL( marker_ )
+      : marker( marker_ )
     {}
 
+    vk::PerformanceMarkerInfoINTEL & operator=( vk::PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceMarkerInfoINTEL ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PerformanceMarkerInfoINTEL( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PerformanceMarkerInfoINTEL::operator=(rhs);
+      *this = *reinterpret_cast<vk::PerformanceMarkerInfoINTEL const *>(&rhs);
       return *this;
     }
 
@@ -44599,61 +41416,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PerformanceMarkerInfoINTEL::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL;
+    const void* pNext = nullptr;
+    uint64_t marker;
   };
   static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PerformanceOverrideInfoINTEL
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware,
-                                                         vk::Bool32 enable_ = 0,
-                                                         uint64_t parameter_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : type( type_ )
-        , enable( enable_ )
-        , parameter( parameter_ )
-      {}
-
-      PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(this) = rhs;
-      }
-
-      PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PerformanceOverrideInfoINTEL
   {
     VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware,
                                                        vk::Bool32 enable_ = 0,
                                                        uint64_t parameter_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PerformanceOverrideInfoINTEL( type_, enable_, parameter_ )
+      : type( type_ )
+      , enable( enable_ )
+      , parameter( parameter_ )
     {}
 
+    vk::PerformanceOverrideInfoINTEL & operator=( vk::PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceOverrideInfoINTEL ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PerformanceOverrideInfoINTEL( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PerformanceOverrideInfoINTEL::operator=(rhs);
+      *this = *reinterpret_cast<vk::PerformanceOverrideInfoINTEL const *>(&rhs);
       return *this;
     }
 
@@ -44705,53 +41499,101 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PerformanceOverrideInfoINTEL::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL;
+    const void* pNext = nullptr;
+    vk::PerformanceOverrideTypeINTEL type;
+    vk::Bool32 enable;
+    uint64_t parameter;
   };
   static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceOverrideInfoINTEL>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PerformanceQuerySubmitInfoKHR
   {
-    struct PerformanceStreamMarkerInfoINTEL
+    VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( uint32_t counterPassIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : counterPassIndex( counterPassIndex_ )
+    {}
+
+    vk::PerformanceQuerySubmitInfoKHR & operator=( vk::PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    protected:
-      VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : marker( marker_ )
-      {}
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceQuerySubmitInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
-      PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
-      }
+    PerformanceQuerySubmitInfoKHR( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
 
-      PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
-        return *this;
-      }
+    PerformanceQuerySubmitInfoKHR& operator=( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<vk::PerformanceQuerySubmitInfoKHR const *>(&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!" );
-  }
+    PerformanceQuerySubmitInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
 
-  struct PerformanceStreamMarkerInfoINTEL : public layout::PerformanceStreamMarkerInfoINTEL
+    PerformanceQuerySubmitInfoKHR & setCounterPassIndex( uint32_t counterPassIndex_ ) VULKAN_HPP_NOEXCEPT
+    {
+      counterPassIndex = counterPassIndex_;
+      return *this;
+    }
+
+    operator VkPerformanceQuerySubmitInfoKHR const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>( this );
+    }
+
+    operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>( this );
+    }
+
+    bool operator==( PerformanceQuerySubmitInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( counterPassIndex == rhs.counterPassIndex );
+    }
+
+    bool operator!=( PerformanceQuerySubmitInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    const vk::StructureType sType = StructureType::ePerformanceQuerySubmitInfoKHR;
+    const void* pNext = nullptr;
+    uint32_t counterPassIndex;
+  };
+  static_assert( sizeof( PerformanceQuerySubmitInfoKHR ) == sizeof( VkPerformanceQuerySubmitInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PerformanceQuerySubmitInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  struct PerformanceStreamMarkerInfoINTEL
   {
     VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PerformanceStreamMarkerInfoINTEL( marker_ )
+      : marker( marker_ )
     {}
 
+    vk::PerformanceStreamMarkerInfoINTEL & operator=( vk::PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceStreamMarkerInfoINTEL ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PerformanceStreamMarkerInfoINTEL( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PerformanceStreamMarkerInfoINTEL::operator=(rhs);
+      *this = *reinterpret_cast<vk::PerformanceStreamMarkerInfoINTEL const *>(&rhs);
       return *this;
     }
 
@@ -44789,8 +41631,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PerformanceStreamMarkerInfoINTEL::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL;
+    const void* pNext = nullptr;
+    uint32_t marker;
   };
   static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PerformanceStreamMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" );
@@ -44881,12 +41725,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPerformanceValueINTEL*>(this) = rhs;
+      *this = rhs;
     }
 
     PerformanceValueINTEL& operator=( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPerformanceValueINTEL*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PerformanceValueINTEL const *>(&rhs);
       return *this;
     }
 
@@ -44919,59 +41763,32 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0,
-                                                               vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
-                                                               vk::Bool32 storagePushConstant16_ = 0,
-                                                               vk::Bool32 storageInputOutput16_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
-        , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
-        , storagePushConstant16( storagePushConstant16_ )
-        , storageInputOutput16( storageInputOutput16_ )
-      {}
-
-      PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this) = rhs;
-      }
-
-      PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDevice16BitStorageFeatures
   {
     VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0,
                                                              vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
                                                              vk::Bool32 storagePushConstant16_ = 0,
                                                              vk::Bool32 storageInputOutput16_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevice16BitStorageFeatures( storageBuffer16BitAccess_, uniformAndStorageBuffer16BitAccess_, storagePushConstant16_, storageInputOutput16_ )
+      : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
+      , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
+      , storagePushConstant16( storagePushConstant16_ )
+      , storageInputOutput16( storageInputOutput16_ )
     {}
 
+    vk::PhysicalDevice16BitStorageFeatures & operator=( vk::PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevice16BitStorageFeatures ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevice16BitStorageFeatures( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDevice16BitStorageFeatures::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDevice16BitStorageFeatures const *>(&rhs);
       return *this;
     }
 
@@ -45030,61 +41847,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDevice16BitStorageFeatures::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0,
-                                                                 vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
-                                                                 vk::Bool32 storagePushConstant8_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
-        , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
-        , storagePushConstant8( storagePushConstant8_ )
-      {}
-
-      PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDevice8BitStorageFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0,
                                                                vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
                                                                vk::Bool32 storagePushConstant8_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevice8BitStorageFeaturesKHR( storageBuffer8BitAccess_, uniformAndStorageBuffer8BitAccess_, storagePushConstant8_ )
+      : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
+      , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
+      , storagePushConstant8( storagePushConstant8_ )
     {}
 
+    vk::PhysicalDevice8BitStorageFeaturesKHR & operator=( vk::PhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevice8BitStorageFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevice8BitStorageFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDevice8BitStorageFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDevice8BitStorageFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -45136,53 +41933,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDevice8BitStorageFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 storageBuffer8BitAccess;
+    vk::Bool32 uniformAndStorageBuffer8BitAccess;
+    vk::Bool32 storagePushConstant8;
   };
   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!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceASTCDecodeFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : decodeModeSharedExponent( decodeModeSharedExponent_ )
-      {}
-
-      PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceASTCDecodeFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceASTCDecodeFeaturesEXT( decodeModeSharedExponent_ )
+      : decodeModeSharedExponent( decodeModeSharedExponent_ )
     {}
 
+    vk::PhysicalDeviceASTCDecodeFeaturesEXT & operator=( vk::PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceASTCDecodeFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceASTCDecodeFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceASTCDecodeFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceASTCDecodeFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -45220,53 +42000,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceASTCDecodeFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 decodeModeSharedExponent;
   };
   static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceASTCDecodeFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
-      {}
-
-      PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT
+  struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( advancedBlendCoherentOperations_ )
+      : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
     {}
 
+    vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -45304,57 +42065,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 advancedBlendCoherentOperations;
   };
   static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceBlendOperationAdvancedFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceBlendOperationAdvancedPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
   {
-    PhysicalDeviceBlendOperationAdvancedPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+    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 ) VULKAN_HPP_NOEXCEPT
+      : advancedBlendMaxColorAttachments( advancedBlendMaxColorAttachments_ )
+      , advancedBlendIndependentBlend( advancedBlendIndependentBlend_ )
+      , advancedBlendNonPremultipliedSrcColor( advancedBlendNonPremultipliedSrcColor_ )
+      , advancedBlendNonPremultipliedDstColor( advancedBlendNonPremultipliedDstColor_ )
+      , advancedBlendCorrelatedOverlap( advancedBlendCorrelatedOverlap_ )
+      , advancedBlendAllOperations( advancedBlendAllOperations_ )
     {}
 
+    vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT & operator=( vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -45385,61 +42133,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceBlendOperationAdvancedPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0,
-                                                                         vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0,
-                                                                         vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : bufferDeviceAddress( bufferDeviceAddress_ )
-        , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ )
-        , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
-      {}
-
-      PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0,
                                                                        vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0,
                                                                        vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( bufferDeviceAddress_, bufferDeviceAddressCaptureReplay_, bufferDeviceAddressMultiDevice_ )
+      : bufferDeviceAddress( bufferDeviceAddress_ )
+      , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ )
+      , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
     {}
 
+    vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -45491,53 +42221,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 bufferDeviceAddress;
+    vk::Bool32 bufferDeviceAddressCaptureReplay;
+    vk::Bool32 bufferDeviceAddressMultiDevice;
   };
   static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceBufferDeviceAddressFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceCoherentMemoryFeaturesAMD
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : deviceCoherentMemory( deviceCoherentMemory_ )
-      {}
-
-      PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this) = rhs;
-      }
-
-      PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceCoherentMemoryFeaturesAMD
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( deviceCoherentMemory_ )
+      : deviceCoherentMemory( deviceCoherentMemory_ )
     {}
 
+    vk::PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( vk::PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCoherentMemoryFeaturesAMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceCoherentMemoryFeaturesAMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceCoherentMemoryFeaturesAMD const *>(&rhs);
       return *this;
     }
 
@@ -45575,57 +42288,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceCoherentMemoryFeaturesAMD::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD;
+    void* pNext = nullptr;
+    vk::Bool32 deviceCoherentMemory;
   };
   static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCoherentMemoryFeaturesAMD>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0,
-                                                                             vk::Bool32 computeDerivativeGroupLinear_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
-        , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
-      {}
-
-      PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0,
                                                                            vk::Bool32 computeDerivativeGroupLinear_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( computeDerivativeGroupQuads_, computeDerivativeGroupLinear_ )
+      : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
+      , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
     {}
 
+    vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV & operator=( vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -45670,57 +42362,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 computeDerivativeGroupQuads;
+    vk::Bool32 computeDerivativeGroupLinear;
   };
   static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceComputeShaderDerivativesFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceConditionalRenderingFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0,
-                                                                          vk::Bool32 inheritedConditionalRendering_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : conditionalRendering( conditionalRendering_ )
-        , inheritedConditionalRendering( inheritedConditionalRendering_ )
-      {}
-
-      PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceConditionalRenderingFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0,
                                                                         vk::Bool32 inheritedConditionalRendering_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( conditionalRendering_, inheritedConditionalRendering_ )
+      : conditionalRendering( conditionalRendering_ )
+      , inheritedConditionalRendering( inheritedConditionalRendering_ )
     {}
 
+    vk::PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( vk::PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceConditionalRenderingFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceConditionalRenderingFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceConditionalRenderingFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -45765,60 +42437,51 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceConditionalRenderingFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 conditionalRendering;
+    vk::Bool32 inheritedConditionalRendering;
   };
   static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceConditionalRenderingFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceConservativeRasterizationPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceConservativeRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceConservativeRasterizationPropertiesEXT
   {
-    PhysicalDeviceConservativeRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceConservativeRasterizationPropertiesEXT()
+    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 ) VULKAN_HPP_NOEXCEPT
+      : primitiveOverestimationSize( primitiveOverestimationSize_ )
+      , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ )
+      , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ )
+      , primitiveUnderestimation( primitiveUnderestimation_ )
+      , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ )
+      , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ )
+      , degenerateLinesRasterized( degenerateLinesRasterized_ )
+      , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ )
+      , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ )
     {}
 
+    vk::PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=( vk::PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceConservativeRasterizationPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceConservativeRasterizationPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceConservativeRasterizationPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -45852,57 +42515,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceConservativeRasterizationPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceCooperativeMatrixFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0,
-                                                                      vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : cooperativeMatrix( cooperativeMatrix_ )
-        , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ )
-      {}
-
-      PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceCooperativeMatrixFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0,
                                                                     vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( cooperativeMatrix_, cooperativeMatrixRobustBufferAccess_ )
+      : cooperativeMatrix( cooperativeMatrix_ )
+      , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ )
     {}
 
+    vk::PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( vk::PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCooperativeMatrixFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceCooperativeMatrixFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceCooperativeMatrixFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -45947,52 +42597,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceCooperativeMatrixFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 cooperativeMatrix;
+    vk::Bool32 cooperativeMatrixRobustBufferAccess;
   };
   static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCooperativeMatrixFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceCooperativeMatrixPropertiesNV
   {
-    struct PhysicalDeviceCooperativeMatrixPropertiesNV
-    {
-    protected:
-      PhysicalDeviceCooperativeMatrixPropertiesNV() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceCooperativeMatrixPropertiesNV
-  {
-    PhysicalDeviceCooperativeMatrixPropertiesNV() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCooperativeMatrixPropertiesNV()
+    PhysicalDeviceCooperativeMatrixPropertiesNV( vk::ShaderStageFlags cooperativeMatrixSupportedStages_ = vk::ShaderStageFlags() ) VULKAN_HPP_NOEXCEPT
+      : cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ )
     {}
 
+    vk::PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( vk::PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCooperativeMatrixPropertiesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCooperativeMatrixPropertiesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceCooperativeMatrixPropertiesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceCooperativeMatrixPropertiesNV const *>(&rhs);
       return *this;
     }
 
@@ -46018,53 +42651,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceCooperativeMatrixPropertiesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV;
+    void* pNext = nullptr;
+    vk::ShaderStageFlags cooperativeMatrixSupportedStages;
   };
   static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCooperativeMatrixPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceCornerSampledImageFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : cornerSampledImage( cornerSampledImage_ )
-      {}
-
-      PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceCornerSampledImageFeaturesNV
+  struct PhysicalDeviceCornerSampledImageFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCornerSampledImageFeaturesNV( cornerSampledImage_ )
+      : cornerSampledImage( cornerSampledImage_ )
     {}
 
+    vk::PhysicalDeviceCornerSampledImageFeaturesNV & operator=( vk::PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCornerSampledImageFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCornerSampledImageFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceCornerSampledImageFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceCornerSampledImageFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -46102,53 +42716,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceCornerSampledImageFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 cornerSampledImage;
   };
   static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCornerSampledImageFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceCoverageReductionModeFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : coverageReductionMode( coverageReductionMode_ )
-      {}
-
-      PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PhysicalDeviceCoverageReductionModeFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( coverageReductionMode_ )
+      : coverageReductionMode( coverageReductionMode_ )
     {}
 
+    vk::PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( vk::PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCoverageReductionModeFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceCoverageReductionModeFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceCoverageReductionModeFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -46186,53 +42781,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceCoverageReductionModeFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 coverageReductionMode;
   };
   static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceCoverageReductionModeFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
-      {}
-
-      PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( dedicatedAllocationImageAliasing_ )
+      : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
     {}
 
+    vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & operator=( vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -46270,53 +42846,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 dedicatedAllocationImageAliasing;
   };
   static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceDepthClipEnableFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : depthClipEnable( depthClipEnable_ )
-      {}
-
-      PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceDepthClipEnableFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( depthClipEnable_ )
+      : depthClipEnable( depthClipEnable_ )
     {}
 
+    vk::PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( vk::PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDepthClipEnableFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceDepthClipEnableFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceDepthClipEnableFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -46354,55 +42911,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceDepthClipEnableFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 depthClipEnable;
   };
   static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDepthClipEnableFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceDepthStencilResolvePropertiesKHR
-    {
-    protected:
-      PhysicalDeviceDepthStencilResolvePropertiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceDepthStencilResolvePropertiesKHR
   {
-    PhysicalDeviceDepthStencilResolvePropertiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDepthStencilResolvePropertiesKHR()
+    PhysicalDeviceDepthStencilResolvePropertiesKHR( vk::ResolveModeFlagsKHR supportedDepthResolveModes_ = vk::ResolveModeFlagsKHR(),
+                                                    vk::ResolveModeFlagsKHR supportedStencilResolveModes_ = vk::ResolveModeFlagsKHR(),
+                                                    vk::Bool32 independentResolveNone_ = 0,
+                                                    vk::Bool32 independentResolve_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : supportedDepthResolveModes( supportedDepthResolveModes_ )
+      , supportedStencilResolveModes( supportedStencilResolveModes_ )
+      , independentResolveNone( independentResolveNone_ )
+      , independentResolve( independentResolve_ )
     {}
 
+    vk::PhysicalDeviceDepthStencilResolvePropertiesKHR & operator=( vk::PhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDepthStencilResolvePropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDepthStencilResolvePropertiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceDepthStencilResolvePropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -46431,98 +42973,18 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDepthStencilResolvePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceDescriptorIndexingFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : 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 ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceDescriptorIndexingFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0,
                                                                       vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0,
@@ -46544,16 +43006,42 @@ namespace VULKAN_HPP_NAMESPACE
                                                                       vk::Bool32 descriptorBindingPartiallyBound_ = 0,
                                                                       vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0,
                                                                       vk::Bool32 runtimeDescriptorArray_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( shaderInputAttachmentArrayDynamicIndexing_, shaderUniformTexelBufferArrayDynamicIndexing_, shaderStorageTexelBufferArrayDynamicIndexing_, shaderUniformBufferArrayNonUniformIndexing_, shaderSampledImageArrayNonUniformIndexing_, shaderStorageBufferArrayNonUniformIndexing_, shaderStorageImageArrayNonUniformIndexing_, shaderInputAttachmentArrayNonUniformIndexing_, shaderUniformTexelBufferArrayNonUniformIndexing_, shaderStorageTexelBufferArrayNonUniformIndexing_, descriptorBindingUniformBufferUpdateAfterBind_, descriptorBindingSampledImageUpdateAfterBind_, descriptorBindingStorageImageUpdateAfterBind_, descriptorBindingStorageBufferUpdateAfterBind_, descriptorBindingUniformTexelBufferUpdateAfterBind_, descriptorBindingStorageTexelBufferUpdateAfterBind_, descriptorBindingUpdateUnusedWhilePending_, descriptorBindingPartiallyBound_, descriptorBindingVariableDescriptorCount_, runtimeDescriptorArray_ )
-    {}
+      : 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_ )
+    {}
+
+    vk::PhysicalDeviceDescriptorIndexingFeaturesEXT & operator=( vk::PhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDescriptorIndexingFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceDescriptorIndexingFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -46724,74 +43212,97 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::sType;
+  public:
+    const 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 ), "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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceDescriptorIndexingPropertiesEXT
-  {
-    PhysicalDeviceDescriptorIndexingPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDescriptorIndexingPropertiesEXT()
-    {}
+  struct PhysicalDeviceDescriptorIndexingPropertiesEXT
+  {
+    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 ) VULKAN_HPP_NOEXCEPT
+      : 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_ )
+    {}
+
+    vk::PhysicalDeviceDescriptorIndexingPropertiesEXT & operator=( vk::PhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDescriptorIndexingPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDescriptorIndexingPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceDescriptorIndexingPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -46839,52 +43350,56 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::sType;
+  public:
+    const 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 ), "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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceDiscardRectanglePropertiesEXT
+  struct PhysicalDeviceDiscardRectanglePropertiesEXT
   {
-    PhysicalDeviceDiscardRectanglePropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDiscardRectanglePropertiesEXT()
+    PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxDiscardRectangles( maxDiscardRectangles_ )
     {}
 
+    vk::PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( vk::PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDiscardRectanglePropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDiscardRectanglePropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceDiscardRectanglePropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceDiscardRectanglePropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -46910,55 +43425,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceDiscardRectanglePropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
+    void* pNext = nullptr;
+    uint32_t maxDiscardRectangles;
   };
   static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceDiscardRectanglePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceDriverPropertiesKHR
   {
-    struct PhysicalDeviceDriverPropertiesKHR
+    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() ) VULKAN_HPP_NOEXCEPT
+      : driverID( driverID_ )
+      , driverName{}
+      , driverInfo{}
+      , conformanceVersion( conformanceVersion_ )
     {
-    protected:
-      PhysicalDeviceDriverPropertiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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!" );
-  }
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DRIVER_NAME_SIZE_KHR,VK_MAX_DRIVER_NAME_SIZE_KHR>::copy( driverName, driverName_ );
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DRIVER_INFO_SIZE_KHR,VK_MAX_DRIVER_INFO_SIZE_KHR>::copy( driverInfo, driverInfo_ );
+    }
 
-  struct PhysicalDeviceDriverPropertiesKHR : public layout::PhysicalDeviceDriverPropertiesKHR
-  {
-    PhysicalDeviceDriverPropertiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDriverPropertiesKHR()
-    {}
+    vk::PhysicalDeviceDriverPropertiesKHR & operator=( vk::PhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDriverPropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceDriverPropertiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceDriverPropertiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceDriverPropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -46987,53 +43490,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceDriverPropertiesKHR::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : exclusiveScissor( exclusiveScissor_ )
-      {}
-
-      PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PhysicalDeviceExclusiveScissorFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExclusiveScissorFeaturesNV( exclusiveScissor_ )
+      : exclusiveScissor( exclusiveScissor_ )
     {}
 
+    vk::PhysicalDeviceExclusiveScissorFeaturesNV & operator=( vk::PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExclusiveScissorFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExclusiveScissorFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceExclusiveScissorFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceExclusiveScissorFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -47071,61 +43558,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceExclusiveScissorFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 exclusiveScissor;
   };
   static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceExclusiveScissorFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceExternalBufferInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
-                                                             vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
-                                                             vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , usage( usage_ )
-        , handleType( handleType_ )
-      {}
-
-      PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this) = rhs;
-      }
-
-      PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceExternalBufferInfo
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
                                                            vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
                                                            vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalBufferInfo( flags_, usage_, handleType_ )
+      : flags( flags_ )
+      , usage( usage_ )
+      , handleType( handleType_ )
     {}
 
+    vk::PhysicalDeviceExternalBufferInfo & operator=( vk::PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalBufferInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalBufferInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceExternalBufferInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceExternalBufferInfo const *>(&rhs);
       return *this;
     }
 
@@ -47177,53 +43641,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceExternalBufferInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
+    const void* pNext = nullptr;
+    vk::BufferCreateFlags flags;
+    vk::BufferUsageFlags usage;
+    vk::ExternalMemoryHandleTypeFlagBits handleType;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : handleType( handleType_ )
-      {}
-
-      PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this) = rhs;
-      }
-
-      PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceExternalFenceInfo
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalFenceInfo( handleType_ )
+      : handleType( handleType_ )
     {}
 
+    vk::PhysicalDeviceExternalFenceInfo & operator=( vk::PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalFenceInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalFenceInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceExternalFenceInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceExternalFenceInfo const *>(&rhs);
       return *this;
     }
 
@@ -47261,53 +43708,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceExternalFenceInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
+    const void* pNext = nullptr;
+    vk::ExternalFenceHandleTypeFlagBits handleType;
   };
   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!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceExternalImageFormatInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : handleType( handleType_ )
-      {}
-
-      PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this) = rhs;
-      }
-
-      PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceExternalImageFormatInfo
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalImageFormatInfo( handleType_ )
+      : handleType( handleType_ )
     {}
 
+    vk::PhysicalDeviceExternalImageFormatInfo & operator=( vk::PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalImageFormatInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalImageFormatInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceExternalImageFormatInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceExternalImageFormatInfo const *>(&rhs);
       return *this;
     }
 
@@ -47345,52 +43773,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceExternalImageFormatInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
+    const void* pNext = nullptr;
+    vk::ExternalMemoryHandleTypeFlagBits handleType;
   };
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceExternalMemoryHostPropertiesEXT
+  struct PhysicalDeviceExternalMemoryHostPropertiesEXT
   {
-    PhysicalDeviceExternalMemoryHostPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalMemoryHostPropertiesEXT()
+    PhysicalDeviceExternalMemoryHostPropertiesEXT( vk::DeviceSize minImportedHostPointerAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
     {}
 
+    vk::PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( vk::PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalMemoryHostPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalMemoryHostPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceExternalMemoryHostPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -47416,53 +43826,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
+    void* pNext = nullptr;
+    vk::DeviceSize minImportedHostPointerAlignment;
   };
   static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceExternalMemoryHostPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceExternalSemaphoreInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : handleType( handleType_ )
-      {}
-
-      PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this) = rhs;
-      }
-
-      PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceExternalSemaphoreInfo
+  struct PhysicalDeviceExternalSemaphoreInfo
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalSemaphoreInfo( handleType_ )
+      : handleType( handleType_ )
     {}
 
+    vk::PhysicalDeviceExternalSemaphoreInfo & operator=( vk::PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalSemaphoreInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceExternalSemaphoreInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceExternalSemaphoreInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceExternalSemaphoreInfo const *>(&rhs);
       return *this;
     }
 
@@ -47500,53 +43891,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceExternalSemaphoreInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
+    const void* pNext = nullptr;
+    vk::ExternalSemaphoreHandleTypeFlagBits handleType;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() ) VULKAN_HPP_NOEXCEPT
-        : features( features_ )
-      {}
-
-      PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this) = rhs;
-      }
-
-      PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceFeatures2
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFeatures2( features_ )
+      : features( features_ )
     {}
 
+    vk::PhysicalDeviceFeatures2 & operator=( vk::PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFeatures2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFeatures2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceFeatures2::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceFeatures2 const *>(&rhs);
       return *this;
     }
 
@@ -47584,68 +43956,66 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceFeatures2::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceFeatures2;
+    void* pNext = nullptr;
+    vk::PhysicalDeviceFeatures features;
   };
   static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFeatures2>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceFloatControlsPropertiesKHR
-    {
-    protected:
-      PhysicalDeviceFloatControlsPropertiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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 : public layout::PhysicalDeviceFloatControlsPropertiesKHR
-  {
-    PhysicalDeviceFloatControlsPropertiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFloatControlsPropertiesKHR()
-    {}
+  struct PhysicalDeviceFloatControlsPropertiesKHR
+  {
+    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 ) VULKAN_HPP_NOEXCEPT
+      : 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_ )
+    {}
+
+    vk::PhysicalDeviceFloatControlsPropertiesKHR & operator=( vk::PhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFloatControlsPropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFloatControlsPropertiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceFloatControlsPropertiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceFloatControlsPropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -47687,54 +44057,54 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceFloatControlsPropertiesKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFloatControlsPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceFragmentDensityMapFeaturesEXT
-    {
-    protected:
-      PhysicalDeviceFragmentDensityMapFeaturesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceFragmentDensityMapFeaturesEXT
   {
-    PhysicalDeviceFragmentDensityMapFeaturesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFragmentDensityMapFeaturesEXT()
+    PhysicalDeviceFragmentDensityMapFeaturesEXT( vk::Bool32 fragmentDensityMap_ = 0,
+                                                 vk::Bool32 fragmentDensityMapDynamic_ = 0,
+                                                 vk::Bool32 fragmentDensityMapNonSubsampledImages_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : fragmentDensityMap( fragmentDensityMap_ )
+      , fragmentDensityMapDynamic( fragmentDensityMapDynamic_ )
+      , fragmentDensityMapNonSubsampledImages( fragmentDensityMapNonSubsampledImages_ )
     {}
 
+    vk::PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( vk::PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentDensityMapFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFragmentDensityMapFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceFragmentDensityMapFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -47762,54 +44132,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 fragmentDensityMap;
+    vk::Bool32 fragmentDensityMapDynamic;
+    vk::Bool32 fragmentDensityMapNonSubsampledImages;
   };
   static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMapFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceFragmentDensityMapPropertiesEXT
   {
-    struct PhysicalDeviceFragmentDensityMapPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceFragmentDensityMapPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    PhysicalDeviceFragmentDensityMapPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFragmentDensityMapPropertiesEXT()
+    PhysicalDeviceFragmentDensityMapPropertiesEXT( vk::Extent2D minFragmentDensityTexelSize_ = vk::Extent2D(),
+                                                   vk::Extent2D maxFragmentDensityTexelSize_ = vk::Extent2D(),
+                                                   vk::Bool32 fragmentDensityInvocations_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : minFragmentDensityTexelSize( minFragmentDensityTexelSize_ )
+      , maxFragmentDensityTexelSize( maxFragmentDensityTexelSize_ )
+      , fragmentDensityInvocations( fragmentDensityInvocations_ )
     {}
 
+    vk::PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( vk::PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentDensityMapPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFragmentDensityMapPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceFragmentDensityMapPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -47837,53 +44193,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT;
+    void* pNext = nullptr;
+    vk::Extent2D minFragmentDensityTexelSize;
+    vk::Extent2D maxFragmentDensityTexelSize;
+    vk::Bool32 fragmentDensityInvocations;
   };
   static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMapPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
-      {}
-
-      PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( fragmentShaderBarycentric_ )
+      : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
     {}
 
+    vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV & operator=( vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -47921,61 +44260,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 fragmentShaderBarycentric;
   };
   static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFragmentShaderBarycentricFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0,
-                                                                             vk::Bool32 fragmentShaderPixelInterlock_ = 0,
-                                                                             vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ )
-        , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ )
-        , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ )
-      {}
-
-      PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0,
                                                                            vk::Bool32 fragmentShaderPixelInterlock_ = 0,
                                                                            vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( fragmentShaderSampleInterlock_, fragmentShaderPixelInterlock_, fragmentShaderShadingRateInterlock_ )
+      : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ )
+      , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ )
+      , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ )
     {}
 
+    vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -48027,54 +44343,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 fragmentShaderSampleInterlock;
+    vk::Bool32 fragmentShaderPixelInterlock;
+    vk::Bool32 fragmentShaderShadingRateInterlock;
   };
   static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceFragmentShaderInterlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceGroupProperties
   {
-    struct PhysicalDeviceGroupProperties
+    PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = 0,
+                                   std::array<vk::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE> const& physicalDevices_ = { { vk::PhysicalDevice() } },
+                                   vk::Bool32 subsetAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : physicalDeviceCount( physicalDeviceCount_ )
+      , physicalDevices{}
+      , subsetAllocation( subsetAllocation_ )
     {
-    protected:
-      PhysicalDeviceGroupProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this) = rhs;
-      }
-
-      PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this) = rhs;
-        return *this;
-      }
-
-    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!" );
-  }
+      vk::ConstExpressionArrayCopy<vk::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE,VK_MAX_DEVICE_GROUP_SIZE>::copy( physicalDevices, physicalDevices_ );
+    }
 
-  struct PhysicalDeviceGroupProperties : public layout::PhysicalDeviceGroupProperties
-  {
-    PhysicalDeviceGroupProperties() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceGroupProperties()
-    {}
+    vk::PhysicalDeviceGroupProperties & operator=( vk::PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceGroupProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceGroupProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceGroupProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceGroupProperties const *>(&rhs);
       return *this;
     }
 
@@ -48102,53 +44406,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceGroupProperties::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : hostQueryReset( hostQueryReset_ )
-      {}
-
-      PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceHostQueryResetFeaturesEXT
+  struct PhysicalDeviceHostQueryResetFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceHostQueryResetFeaturesEXT( hostQueryReset_ )
+      : hostQueryReset( hostQueryReset_ )
     {}
 
+    vk::PhysicalDeviceHostQueryResetFeaturesEXT & operator=( vk::PhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceHostQueryResetFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceHostQueryResetFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceHostQueryResetFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceHostQueryResetFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -48186,56 +44473,46 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceHostQueryResetFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 hostQueryReset;
   };
   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
   {
-    struct PhysicalDeviceIDProperties
+    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 ) VULKAN_HPP_NOEXCEPT
+      : deviceUUID{}
+      , driverUUID{}
+      , deviceLUID{}
+      , deviceNodeMask( deviceNodeMask_ )
+      , deviceLUIDValid( deviceLUIDValid_ )
     {
-    protected:
-      PhysicalDeviceIDProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this) = rhs;
-      }
-
-      PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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!" );
-  }
+      vk::ConstExpressionArrayCopy<uint8_t,VK_UUID_SIZE,VK_UUID_SIZE>::copy( deviceUUID, deviceUUID_ );
+      vk::ConstExpressionArrayCopy<uint8_t,VK_UUID_SIZE,VK_UUID_SIZE>::copy( driverUUID, driverUUID_ );
+      vk::ConstExpressionArrayCopy<uint8_t,VK_LUID_SIZE,VK_LUID_SIZE>::copy( deviceLUID, deviceLUID_ );
+    }
 
-  struct PhysicalDeviceIDProperties : public layout::PhysicalDeviceIDProperties
-  {
-    PhysicalDeviceIDProperties() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceIDProperties()
-    {}
+    vk::PhysicalDeviceIDProperties & operator=( vk::PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceIDProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceIDProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceIDProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceIDProperties const *>(&rhs);
       return *this;
     }
 
@@ -48265,65 +44542,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceIDProperties::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
-                                                                        vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
-                                                                        uint32_t queueFamilyIndexCount_ = 0,
-                                                                        const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : drmFormatModifier( drmFormatModifier_ )
-        , sharingMode( sharingMode_ )
-        , queueFamilyIndexCount( queueFamilyIndexCount_ )
-        , pQueueFamilyIndices( pQueueFamilyIndices_ )
-      {}
-
-      PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceImageDrmFormatModifierInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
                                                                       vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
                                                                       uint32_t queueFamilyIndexCount_ = 0,
                                                                       const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( drmFormatModifier_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ )
+      : drmFormatModifier( drmFormatModifier_ )
+      , sharingMode( sharingMode_ )
+      , queueFamilyIndexCount( queueFamilyIndexCount_ )
+      , pQueueFamilyIndices( pQueueFamilyIndices_ )
     {}
 
+    vk::PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( vk::PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageDrmFormatModifierInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceImageDrmFormatModifierInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -48382,69 +44638,45 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceImageDrmFormatModifierInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceImageFormatInfo2
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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() ) VULKAN_HPP_NOEXCEPT
-        : format( format_ )
-        , type( type_ )
-        , tiling( tiling_ )
-        , usage( usage_ )
-        , flags( flags_ )
-      {}
-
-      PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this) = rhs;
-      }
-
-      PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceImageFormatInfo2
   {
     VULKAN_HPP_CONSTEXPR 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() ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceImageFormatInfo2( format_, type_, tiling_, usage_, flags_ )
+      : format( format_ )
+      , type( type_ )
+      , tiling( tiling_ )
+      , usage( usage_ )
+      , flags( flags_ )
     {}
 
+    vk::PhysicalDeviceImageFormatInfo2 & operator=( vk::PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageFormatInfo2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceImageFormatInfo2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceImageFormatInfo2::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceImageFormatInfo2 const *>(&rhs);
       return *this;
     }
 
@@ -48510,53 +44742,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceImageFormatInfo2::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT
-        : imageViewType( imageViewType_ )
-      {}
-
-      PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceImageViewImageFormatInfoEXT
+  struct PhysicalDeviceImageViewImageFormatInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceImageViewImageFormatInfoEXT( imageViewType_ )
+      : imageViewType( imageViewType_ )
     {}
 
+    vk::PhysicalDeviceImageViewImageFormatInfoEXT & operator=( vk::PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageViewImageFormatInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceImageViewImageFormatInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceImageViewImageFormatInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceImageViewImageFormatInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -48594,53 +44811,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceImageViewImageFormatInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT;
+    void* pNext = nullptr;
+    vk::ImageViewType imageViewType;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : imagelessFramebuffer( imagelessFramebuffer_ )
-      {}
-
-      PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PhysicalDeviceImagelessFramebufferFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( imagelessFramebuffer_ )
+      : imagelessFramebuffer( imagelessFramebuffer_ )
     {}
 
+    vk::PhysicalDeviceImagelessFramebufferFeaturesKHR & operator=( vk::PhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImagelessFramebufferFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceImagelessFramebufferFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -48678,53 +44876,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 imagelessFramebuffer;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : indexTypeUint8( indexTypeUint8_ )
-      {}
-
-      PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceIndexTypeUint8FeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( indexTypeUint8_ )
+      : indexTypeUint8( indexTypeUint8_ )
     {}
 
+    vk::PhysicalDeviceIndexTypeUint8FeaturesEXT & operator=( vk::PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceIndexTypeUint8FeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceIndexTypeUint8FeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -48762,57 +44941,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 indexTypeUint8;
   };
   static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceIndexTypeUint8FeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceInlineUniformBlockFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0,
-                                                                        vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : inlineUniformBlock( inlineUniformBlock_ )
-        , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ )
-      {}
-
-      PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceInlineUniformBlockFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0,
                                                                       vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( inlineUniformBlock_, descriptorBindingInlineUniformBlockUpdateAfterBind_ )
+      : inlineUniformBlock( inlineUniformBlock_ )
+      , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ )
     {}
 
+    vk::PhysicalDeviceInlineUniformBlockFeaturesEXT & operator=( vk::PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceInlineUniformBlockFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceInlineUniformBlockFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -48857,56 +45015,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 inlineUniformBlock;
+    vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
   };
   static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceInlineUniformBlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceInlineUniformBlockPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceInlineUniformBlockPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceInlineUniformBlockPropertiesEXT
   {
-    PhysicalDeviceInlineUniformBlockPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceInlineUniformBlockPropertiesEXT()
+    PhysicalDeviceInlineUniformBlockPropertiesEXT( uint32_t maxInlineUniformBlockSize_ = 0,
+                                                   uint32_t maxPerStageDescriptorInlineUniformBlocks_ = 0,
+                                                   uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = 0,
+                                                   uint32_t maxDescriptorSetInlineUniformBlocks_ = 0,
+                                                   uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxInlineUniformBlockSize( maxInlineUniformBlockSize_ )
+      , maxPerStageDescriptorInlineUniformBlocks( maxPerStageDescriptorInlineUniformBlocks_ )
+      , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ )
+      , maxDescriptorSetInlineUniformBlocks( maxDescriptorSetInlineUniformBlocks_ )
+      , maxDescriptorSetUpdateAfterBindInlineUniformBlocks( maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ )
     {}
 
+    vk::PhysicalDeviceInlineUniformBlockPropertiesEXT & operator=( vk::PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceInlineUniformBlockPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceInlineUniformBlockPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceInlineUniformBlockPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -48936,25 +45081,249 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceInlineUniformBlockPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct PhysicalDeviceLimits
   {
-    PhysicalDeviceLimits() VULKAN_HPP_NOEXCEPT
-    {}
+    PhysicalDeviceLimits( uint32_t maxImageDimension1D_ = 0,
+                          uint32_t maxImageDimension2D_ = 0,
+                          uint32_t maxImageDimension3D_ = 0,
+                          uint32_t maxImageDimensionCube_ = 0,
+                          uint32_t maxImageArrayLayers_ = 0,
+                          uint32_t maxTexelBufferElements_ = 0,
+                          uint32_t maxUniformBufferRange_ = 0,
+                          uint32_t maxStorageBufferRange_ = 0,
+                          uint32_t maxPushConstantsSize_ = 0,
+                          uint32_t maxMemoryAllocationCount_ = 0,
+                          uint32_t maxSamplerAllocationCount_ = 0,
+                          vk::DeviceSize bufferImageGranularity_ = 0,
+                          vk::DeviceSize sparseAddressSpaceSize_ = 0,
+                          uint32_t maxBoundDescriptorSets_ = 0,
+                          uint32_t maxPerStageDescriptorSamplers_ = 0,
+                          uint32_t maxPerStageDescriptorUniformBuffers_ = 0,
+                          uint32_t maxPerStageDescriptorStorageBuffers_ = 0,
+                          uint32_t maxPerStageDescriptorSampledImages_ = 0,
+                          uint32_t maxPerStageDescriptorStorageImages_ = 0,
+                          uint32_t maxPerStageDescriptorInputAttachments_ = 0,
+                          uint32_t maxPerStageResources_ = 0,
+                          uint32_t maxDescriptorSetSamplers_ = 0,
+                          uint32_t maxDescriptorSetUniformBuffers_ = 0,
+                          uint32_t maxDescriptorSetUniformBuffersDynamic_ = 0,
+                          uint32_t maxDescriptorSetStorageBuffers_ = 0,
+                          uint32_t maxDescriptorSetStorageBuffersDynamic_ = 0,
+                          uint32_t maxDescriptorSetSampledImages_ = 0,
+                          uint32_t maxDescriptorSetStorageImages_ = 0,
+                          uint32_t maxDescriptorSetInputAttachments_ = 0,
+                          uint32_t maxVertexInputAttributes_ = 0,
+                          uint32_t maxVertexInputBindings_ = 0,
+                          uint32_t maxVertexInputAttributeOffset_ = 0,
+                          uint32_t maxVertexInputBindingStride_ = 0,
+                          uint32_t maxVertexOutputComponents_ = 0,
+                          uint32_t maxTessellationGenerationLevel_ = 0,
+                          uint32_t maxTessellationPatchSize_ = 0,
+                          uint32_t maxTessellationControlPerVertexInputComponents_ = 0,
+                          uint32_t maxTessellationControlPerVertexOutputComponents_ = 0,
+                          uint32_t maxTessellationControlPerPatchOutputComponents_ = 0,
+                          uint32_t maxTessellationControlTotalOutputComponents_ = 0,
+                          uint32_t maxTessellationEvaluationInputComponents_ = 0,
+                          uint32_t maxTessellationEvaluationOutputComponents_ = 0,
+                          uint32_t maxGeometryShaderInvocations_ = 0,
+                          uint32_t maxGeometryInputComponents_ = 0,
+                          uint32_t maxGeometryOutputComponents_ = 0,
+                          uint32_t maxGeometryOutputVertices_ = 0,
+                          uint32_t maxGeometryTotalOutputComponents_ = 0,
+                          uint32_t maxFragmentInputComponents_ = 0,
+                          uint32_t maxFragmentOutputAttachments_ = 0,
+                          uint32_t maxFragmentDualSrcAttachments_ = 0,
+                          uint32_t maxFragmentCombinedOutputResources_ = 0,
+                          uint32_t maxComputeSharedMemorySize_ = 0,
+                          std::array<uint32_t,3> const& maxComputeWorkGroupCount_ = { { 0 } },
+                          uint32_t maxComputeWorkGroupInvocations_ = 0,
+                          std::array<uint32_t,3> const& maxComputeWorkGroupSize_ = { { 0 } },
+                          uint32_t subPixelPrecisionBits_ = 0,
+                          uint32_t subTexelPrecisionBits_ = 0,
+                          uint32_t mipmapPrecisionBits_ = 0,
+                          uint32_t maxDrawIndexedIndexValue_ = 0,
+                          uint32_t maxDrawIndirectCount_ = 0,
+                          float maxSamplerLodBias_ = 0,
+                          float maxSamplerAnisotropy_ = 0,
+                          uint32_t maxViewports_ = 0,
+                          std::array<uint32_t,2> const& maxViewportDimensions_ = { { 0 } },
+                          std::array<float,2> const& viewportBoundsRange_ = { { 0 } },
+                          uint32_t viewportSubPixelBits_ = 0,
+                          size_t minMemoryMapAlignment_ = 0,
+                          vk::DeviceSize minTexelBufferOffsetAlignment_ = 0,
+                          vk::DeviceSize minUniformBufferOffsetAlignment_ = 0,
+                          vk::DeviceSize minStorageBufferOffsetAlignment_ = 0,
+                          int32_t minTexelOffset_ = 0,
+                          uint32_t maxTexelOffset_ = 0,
+                          int32_t minTexelGatherOffset_ = 0,
+                          uint32_t maxTexelGatherOffset_ = 0,
+                          float minInterpolationOffset_ = 0,
+                          float maxInterpolationOffset_ = 0,
+                          uint32_t subPixelInterpolationOffsetBits_ = 0,
+                          uint32_t maxFramebufferWidth_ = 0,
+                          uint32_t maxFramebufferHeight_ = 0,
+                          uint32_t maxFramebufferLayers_ = 0,
+                          vk::SampleCountFlags framebufferColorSampleCounts_ = vk::SampleCountFlags(),
+                          vk::SampleCountFlags framebufferDepthSampleCounts_ = vk::SampleCountFlags(),
+                          vk::SampleCountFlags framebufferStencilSampleCounts_ = vk::SampleCountFlags(),
+                          vk::SampleCountFlags framebufferNoAttachmentsSampleCounts_ = vk::SampleCountFlags(),
+                          uint32_t maxColorAttachments_ = 0,
+                          vk::SampleCountFlags sampledImageColorSampleCounts_ = vk::SampleCountFlags(),
+                          vk::SampleCountFlags sampledImageIntegerSampleCounts_ = vk::SampleCountFlags(),
+                          vk::SampleCountFlags sampledImageDepthSampleCounts_ = vk::SampleCountFlags(),
+                          vk::SampleCountFlags sampledImageStencilSampleCounts_ = vk::SampleCountFlags(),
+                          vk::SampleCountFlags storageImageSampleCounts_ = vk::SampleCountFlags(),
+                          uint32_t maxSampleMaskWords_ = 0,
+                          vk::Bool32 timestampComputeAndGraphics_ = 0,
+                          float timestampPeriod_ = 0,
+                          uint32_t maxClipDistances_ = 0,
+                          uint32_t maxCullDistances_ = 0,
+                          uint32_t maxCombinedClipAndCullDistances_ = 0,
+                          uint32_t discreteQueuePriorities_ = 0,
+                          std::array<float,2> const& pointSizeRange_ = { { 0 } },
+                          std::array<float,2> const& lineWidthRange_ = { { 0 } },
+                          float pointSizeGranularity_ = 0,
+                          float lineWidthGranularity_ = 0,
+                          vk::Bool32 strictLines_ = 0,
+                          vk::Bool32 standardSampleLocations_ = 0,
+                          vk::DeviceSize optimalBufferCopyOffsetAlignment_ = 0,
+                          vk::DeviceSize optimalBufferCopyRowPitchAlignment_ = 0,
+                          vk::DeviceSize nonCoherentAtomSize_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxImageDimension1D( maxImageDimension1D_ )
+      , maxImageDimension2D( maxImageDimension2D_ )
+      , maxImageDimension3D( maxImageDimension3D_ )
+      , maxImageDimensionCube( maxImageDimensionCube_ )
+      , maxImageArrayLayers( maxImageArrayLayers_ )
+      , maxTexelBufferElements( maxTexelBufferElements_ )
+      , maxUniformBufferRange( maxUniformBufferRange_ )
+      , maxStorageBufferRange( maxStorageBufferRange_ )
+      , maxPushConstantsSize( maxPushConstantsSize_ )
+      , maxMemoryAllocationCount( maxMemoryAllocationCount_ )
+      , maxSamplerAllocationCount( maxSamplerAllocationCount_ )
+      , bufferImageGranularity( bufferImageGranularity_ )
+      , sparseAddressSpaceSize( sparseAddressSpaceSize_ )
+      , maxBoundDescriptorSets( maxBoundDescriptorSets_ )
+      , maxPerStageDescriptorSamplers( maxPerStageDescriptorSamplers_ )
+      , maxPerStageDescriptorUniformBuffers( maxPerStageDescriptorUniformBuffers_ )
+      , maxPerStageDescriptorStorageBuffers( maxPerStageDescriptorStorageBuffers_ )
+      , maxPerStageDescriptorSampledImages( maxPerStageDescriptorSampledImages_ )
+      , maxPerStageDescriptorStorageImages( maxPerStageDescriptorStorageImages_ )
+      , maxPerStageDescriptorInputAttachments( maxPerStageDescriptorInputAttachments_ )
+      , maxPerStageResources( maxPerStageResources_ )
+      , maxDescriptorSetSamplers( maxDescriptorSetSamplers_ )
+      , maxDescriptorSetUniformBuffers( maxDescriptorSetUniformBuffers_ )
+      , maxDescriptorSetUniformBuffersDynamic( maxDescriptorSetUniformBuffersDynamic_ )
+      , maxDescriptorSetStorageBuffers( maxDescriptorSetStorageBuffers_ )
+      , maxDescriptorSetStorageBuffersDynamic( maxDescriptorSetStorageBuffersDynamic_ )
+      , maxDescriptorSetSampledImages( maxDescriptorSetSampledImages_ )
+      , maxDescriptorSetStorageImages( maxDescriptorSetStorageImages_ )
+      , maxDescriptorSetInputAttachments( maxDescriptorSetInputAttachments_ )
+      , maxVertexInputAttributes( maxVertexInputAttributes_ )
+      , maxVertexInputBindings( maxVertexInputBindings_ )
+      , maxVertexInputAttributeOffset( maxVertexInputAttributeOffset_ )
+      , maxVertexInputBindingStride( maxVertexInputBindingStride_ )
+      , maxVertexOutputComponents( maxVertexOutputComponents_ )
+      , maxTessellationGenerationLevel( maxTessellationGenerationLevel_ )
+      , maxTessellationPatchSize( maxTessellationPatchSize_ )
+      , maxTessellationControlPerVertexInputComponents( maxTessellationControlPerVertexInputComponents_ )
+      , maxTessellationControlPerVertexOutputComponents( maxTessellationControlPerVertexOutputComponents_ )
+      , maxTessellationControlPerPatchOutputComponents( maxTessellationControlPerPatchOutputComponents_ )
+      , maxTessellationControlTotalOutputComponents( maxTessellationControlTotalOutputComponents_ )
+      , maxTessellationEvaluationInputComponents( maxTessellationEvaluationInputComponents_ )
+      , maxTessellationEvaluationOutputComponents( maxTessellationEvaluationOutputComponents_ )
+      , maxGeometryShaderInvocations( maxGeometryShaderInvocations_ )
+      , maxGeometryInputComponents( maxGeometryInputComponents_ )
+      , maxGeometryOutputComponents( maxGeometryOutputComponents_ )
+      , maxGeometryOutputVertices( maxGeometryOutputVertices_ )
+      , maxGeometryTotalOutputComponents( maxGeometryTotalOutputComponents_ )
+      , maxFragmentInputComponents( maxFragmentInputComponents_ )
+      , maxFragmentOutputAttachments( maxFragmentOutputAttachments_ )
+      , maxFragmentDualSrcAttachments( maxFragmentDualSrcAttachments_ )
+      , maxFragmentCombinedOutputResources( maxFragmentCombinedOutputResources_ )
+      , maxComputeSharedMemorySize( maxComputeSharedMemorySize_ )
+      , maxComputeWorkGroupCount{}
+      , maxComputeWorkGroupInvocations( maxComputeWorkGroupInvocations_ )
+      , maxComputeWorkGroupSize{}
+      , subPixelPrecisionBits( subPixelPrecisionBits_ )
+      , subTexelPrecisionBits( subTexelPrecisionBits_ )
+      , mipmapPrecisionBits( mipmapPrecisionBits_ )
+      , maxDrawIndexedIndexValue( maxDrawIndexedIndexValue_ )
+      , maxDrawIndirectCount( maxDrawIndirectCount_ )
+      , maxSamplerLodBias( maxSamplerLodBias_ )
+      , maxSamplerAnisotropy( maxSamplerAnisotropy_ )
+      , maxViewports( maxViewports_ )
+      , maxViewportDimensions{}
+      , viewportBoundsRange{}
+      , viewportSubPixelBits( viewportSubPixelBits_ )
+      , minMemoryMapAlignment( minMemoryMapAlignment_ )
+      , minTexelBufferOffsetAlignment( minTexelBufferOffsetAlignment_ )
+      , minUniformBufferOffsetAlignment( minUniformBufferOffsetAlignment_ )
+      , minStorageBufferOffsetAlignment( minStorageBufferOffsetAlignment_ )
+      , minTexelOffset( minTexelOffset_ )
+      , maxTexelOffset( maxTexelOffset_ )
+      , minTexelGatherOffset( minTexelGatherOffset_ )
+      , maxTexelGatherOffset( maxTexelGatherOffset_ )
+      , minInterpolationOffset( minInterpolationOffset_ )
+      , maxInterpolationOffset( maxInterpolationOffset_ )
+      , subPixelInterpolationOffsetBits( subPixelInterpolationOffsetBits_ )
+      , maxFramebufferWidth( maxFramebufferWidth_ )
+      , maxFramebufferHeight( maxFramebufferHeight_ )
+      , maxFramebufferLayers( maxFramebufferLayers_ )
+      , framebufferColorSampleCounts( framebufferColorSampleCounts_ )
+      , framebufferDepthSampleCounts( framebufferDepthSampleCounts_ )
+      , framebufferStencilSampleCounts( framebufferStencilSampleCounts_ )
+      , framebufferNoAttachmentsSampleCounts( framebufferNoAttachmentsSampleCounts_ )
+      , maxColorAttachments( maxColorAttachments_ )
+      , sampledImageColorSampleCounts( sampledImageColorSampleCounts_ )
+      , sampledImageIntegerSampleCounts( sampledImageIntegerSampleCounts_ )
+      , sampledImageDepthSampleCounts( sampledImageDepthSampleCounts_ )
+      , sampledImageStencilSampleCounts( sampledImageStencilSampleCounts_ )
+      , storageImageSampleCounts( storageImageSampleCounts_ )
+      , maxSampleMaskWords( maxSampleMaskWords_ )
+      , timestampComputeAndGraphics( timestampComputeAndGraphics_ )
+      , timestampPeriod( timestampPeriod_ )
+      , maxClipDistances( maxClipDistances_ )
+      , maxCullDistances( maxCullDistances_ )
+      , maxCombinedClipAndCullDistances( maxCombinedClipAndCullDistances_ )
+      , discreteQueuePriorities( discreteQueuePriorities_ )
+      , pointSizeRange{}
+      , lineWidthRange{}
+      , pointSizeGranularity( pointSizeGranularity_ )
+      , lineWidthGranularity( lineWidthGranularity_ )
+      , strictLines( strictLines_ )
+      , standardSampleLocations( standardSampleLocations_ )
+      , optimalBufferCopyOffsetAlignment( optimalBufferCopyOffsetAlignment_ )
+      , optimalBufferCopyRowPitchAlignment( optimalBufferCopyRowPitchAlignment_ )
+      , nonCoherentAtomSize( nonCoherentAtomSize_ )
+    {
+      vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( maxComputeWorkGroupCount, maxComputeWorkGroupCount_ );
+      vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( maxComputeWorkGroupSize, maxComputeWorkGroupSize_ );
+      vk::ConstExpressionArrayCopy<uint32_t,2,2>::copy( maxViewportDimensions, maxViewportDimensions_ );
+      vk::ConstExpressionArrayCopy<float,2,2>::copy( viewportBoundsRange, viewportBoundsRange_ );
+      vk::ConstExpressionArrayCopy<float,2,2>::copy( pointSizeRange, pointSizeRange_ );
+      vk::ConstExpressionArrayCopy<float,2,2>::copy( lineWidthRange, lineWidthRange_ );
+    }
 
     PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceLimits*>(this) = rhs;
+      *this = rhs;
     }
 
     PhysicalDeviceLimits& operator=( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceLimits*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PhysicalDeviceLimits const *>(&rhs);
       return *this;
     }
 
@@ -49194,50 +45563,7 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : rectangularLines( rectangularLines_ )
-        , bresenhamLines( bresenhamLines_ )
-        , smoothLines( smoothLines_ )
-        , stippledRectangularLines( stippledRectangularLines_ )
-        , stippledBresenhamLines( stippledBresenhamLines_ )
-        , stippledSmoothLines( stippledSmoothLines_ )
-      {}
-
-      PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceLineRasterizationFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0,
                                                                      vk::Bool32 bresenhamLines_ = 0,
@@ -49245,16 +45571,28 @@ namespace VULKAN_HPP_NAMESPACE
                                                                      vk::Bool32 stippledRectangularLines_ = 0,
                                                                      vk::Bool32 stippledBresenhamLines_ = 0,
                                                                      vk::Bool32 stippledSmoothLines_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rectangularLines_, bresenhamLines_, smoothLines_, stippledRectangularLines_, stippledBresenhamLines_, stippledSmoothLines_ )
+      : rectangularLines( rectangularLines_ )
+      , bresenhamLines( bresenhamLines_ )
+      , smoothLines( smoothLines_ )
+      , stippledRectangularLines( stippledRectangularLines_ )
+      , stippledBresenhamLines( stippledBresenhamLines_ )
+      , stippledSmoothLines( stippledSmoothLines_ )
     {}
 
+    vk::PhysicalDeviceLineRasterizationFeaturesEXT & operator=( vk::PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceLineRasterizationFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceLineRasterizationFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceLineRasterizationFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -49327,52 +45665,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceLineRasterizationFeaturesEXT::sType;
+  public:
+    const 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 ), "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
   {
-    struct PhysicalDeviceLineRasterizationPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceLineRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    PhysicalDeviceLineRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceLineRasterizationPropertiesEXT()
+    PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ )
     {}
 
+    vk::PhysicalDeviceLineRasterizationPropertiesEXT & operator=( vk::PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceLineRasterizationPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceLineRasterizationPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceLineRasterizationPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceLineRasterizationPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -49398,53 +45723,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceLineRasterizationPropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT;
+    void* pNext = nullptr;
+    uint32_t lineSubPixelPrecisionBits;
   };
   static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceLineRasterizationPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceMaintenance3Properties
-    {
-    protected:
-      PhysicalDeviceMaintenance3Properties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this) = rhs;
-      }
-
-      PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceMaintenance3Properties
   {
-    PhysicalDeviceMaintenance3Properties() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMaintenance3Properties()
+    PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = 0,
+                                          vk::DeviceSize maxMemoryAllocationSize_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxPerSetDescriptors( maxPerSetDescriptors_ )
+      , maxMemoryAllocationSize( maxMemoryAllocationSize_ )
     {}
 
+    vk::PhysicalDeviceMaintenance3Properties & operator=( vk::PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMaintenance3Properties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMaintenance3Properties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMaintenance3Properties::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMaintenance3Properties const *>(&rhs);
       return *this;
     }
 
@@ -49471,53 +45779,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMaintenance3Properties::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties;
+    void* pNext = nullptr;
+    uint32_t maxPerSetDescriptors;
+    vk::DeviceSize maxMemoryAllocationSize;
   };
   static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMaintenance3Properties>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceMemoryBudgetPropertiesEXT
   {
-    struct PhysicalDeviceMemoryBudgetPropertiesEXT
+    PhysicalDeviceMemoryBudgetPropertiesEXT( std::array<vk::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapBudget_ = { { 0 } },
+                                             std::array<vk::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapUsage_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+      : heapBudget{}
+      , heapUsage{}
     {
-    protected:
-      PhysicalDeviceMemoryBudgetPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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!" );
-  }
+      vk::ConstExpressionArrayCopy<vk::DeviceSize,VK_MAX_MEMORY_HEAPS,VK_MAX_MEMORY_HEAPS>::copy( heapBudget, heapBudget_ );
+      vk::ConstExpressionArrayCopy<vk::DeviceSize,VK_MAX_MEMORY_HEAPS,VK_MAX_MEMORY_HEAPS>::copy( heapUsage, heapUsage_ );
+    }
 
-  struct PhysicalDeviceMemoryBudgetPropertiesEXT : public layout::PhysicalDeviceMemoryBudgetPropertiesEXT
-  {
-    PhysicalDeviceMemoryBudgetPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMemoryBudgetPropertiesEXT()
-    {}
+    vk::PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( vk::PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryBudgetPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMemoryBudgetPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMemoryBudgetPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMemoryBudgetPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -49544,53 +45839,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMemoryBudgetPropertiesEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : memoryPriority( memoryPriority_ )
-      {}
-
-      PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceMemoryPriorityFeaturesEXT
+  struct PhysicalDeviceMemoryPriorityFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( memoryPriority_ )
+      : memoryPriority( memoryPriority_ )
     {}
 
+    vk::PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( vk::PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryPriorityFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMemoryPriorityFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMemoryPriorityFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -49628,25 +45905,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMemoryPriorityFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 memoryPriority;
   };
   static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMemoryPriorityFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct PhysicalDeviceMemoryProperties
   {
-    PhysicalDeviceMemoryProperties() VULKAN_HPP_NOEXCEPT
-    {}
+    PhysicalDeviceMemoryProperties( uint32_t memoryTypeCount_ = 0,
+                                    std::array<vk::MemoryType,VK_MAX_MEMORY_TYPES> const& memoryTypes_ = { { vk::MemoryType() } },
+                                    uint32_t memoryHeapCount_ = 0,
+                                    std::array<vk::MemoryHeap,VK_MAX_MEMORY_HEAPS> const& memoryHeaps_ = { { vk::MemoryHeap() } } ) VULKAN_HPP_NOEXCEPT
+      : memoryTypeCount( memoryTypeCount_ )
+      , memoryTypes{}
+      , memoryHeapCount( memoryHeapCount_ )
+      , memoryHeaps{}
+    {
+      vk::ConstExpressionArrayCopy<vk::MemoryType,VK_MAX_MEMORY_TYPES,VK_MAX_MEMORY_TYPES>::copy( memoryTypes, memoryTypes_ );
+      vk::ConstExpressionArrayCopy<vk::MemoryHeap,VK_MAX_MEMORY_HEAPS,VK_MAX_MEMORY_HEAPS>::copy( memoryHeaps, memoryHeaps_ );
+    }
 
     PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     PhysicalDeviceMemoryProperties& operator=( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PhysicalDeviceMemoryProperties const *>(&rhs);
       return *this;
     }
 
@@ -49682,46 +45971,26 @@ namespace VULKAN_HPP_NAMESPACE
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this) = rhs;
-      }
-
-      PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceMemoryProperties2
+  struct PhysicalDeviceMemoryProperties2
   {
-    PhysicalDeviceMemoryProperties2() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMemoryProperties2()
+    PhysicalDeviceMemoryProperties2( vk::PhysicalDeviceMemoryProperties memoryProperties_ = vk::PhysicalDeviceMemoryProperties() ) VULKAN_HPP_NOEXCEPT
+      : memoryProperties( memoryProperties_ )
     {}
 
+    vk::PhysicalDeviceMemoryProperties2 & operator=( vk::PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryProperties2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMemoryProperties2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMemoryProperties2::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMemoryProperties2 const *>(&rhs);
       return *this;
     }
 
@@ -49747,57 +46016,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMemoryProperties2::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
+    void* pNext = nullptr;
+    vk::PhysicalDeviceMemoryProperties memoryProperties;
   };
   static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties2>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceMeshShaderFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0,
-                                                               vk::Bool32 meshShader_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : taskShader( taskShader_ )
-        , meshShader( meshShader_ )
-      {}
-
-      PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceMeshShaderFeaturesNV
+  struct PhysicalDeviceMeshShaderFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0,
                                                              vk::Bool32 meshShader_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMeshShaderFeaturesNV( taskShader_, meshShader_ )
+      : taskShader( taskShader_ )
+      , meshShader( meshShader_ )
     {}
 
+    vk::PhysicalDeviceMeshShaderFeaturesNV & operator=( vk::PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMeshShaderFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMeshShaderFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMeshShaderFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMeshShaderFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -49842,64 +46090,62 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMeshShaderFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 taskShader;
+    vk::Bool32 meshShader;
   };
   static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMeshShaderFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceMeshShaderPropertiesNV
-    {
-    protected:
-      PhysicalDeviceMeshShaderPropertiesNV() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    PhysicalDeviceMeshShaderPropertiesNV() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMeshShaderPropertiesNV()
-    {}
+  struct PhysicalDeviceMeshShaderPropertiesNV
+  {
+    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 ) VULKAN_HPP_NOEXCEPT
+      : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ )
+      , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
+      , maxTaskWorkGroupSize{}
+      , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ )
+      , maxTaskOutputCount( maxTaskOutputCount_ )
+      , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
+      , maxMeshWorkGroupSize{}
+      , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ )
+      , maxMeshOutputVertices( maxMeshOutputVertices_ )
+      , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
+      , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
+      , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
+      , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
+    {
+      vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( maxTaskWorkGroupSize, maxTaskWorkGroupSize_ );
+      vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( maxMeshWorkGroupSize, maxMeshWorkGroupSize_ );
+    }
+
+    vk::PhysicalDeviceMeshShaderPropertiesNV & operator=( vk::PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMeshShaderPropertiesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMeshShaderPropertiesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMeshShaderPropertiesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMeshShaderPropertiesNV const *>(&rhs);
       return *this;
     }
 
@@ -49937,61 +46183,50 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMeshShaderPropertiesNV::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0,
-                                                            vk::Bool32 multiviewGeometryShader_ = 0,
-                                                            vk::Bool32 multiviewTessellationShader_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : multiview( multiview_ )
-        , multiviewGeometryShader( multiviewGeometryShader_ )
-        , multiviewTessellationShader( multiviewTessellationShader_ )
-      {}
-
-      PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this) = rhs;
-      }
-
-      PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceMultiviewFeatures
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0,
                                                           vk::Bool32 multiviewGeometryShader_ = 0,
                                                           vk::Bool32 multiviewTessellationShader_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMultiviewFeatures( multiview_, multiviewGeometryShader_, multiviewTessellationShader_ )
+      : multiview( multiview_ )
+      , multiviewGeometryShader( multiviewGeometryShader_ )
+      , multiviewTessellationShader( multiviewTessellationShader_ )
     {}
 
+    vk::PhysicalDeviceMultiviewFeatures & operator=( vk::PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewFeatures ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMultiviewFeatures( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMultiviewFeatures::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMultiviewFeatures const *>(&rhs);
       return *this;
     }
 
@@ -50043,52 +46278,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMultiviewFeatures::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures;
+    void* pNext = nullptr;
+    vk::Bool32 multiview;
+    vk::Bool32 multiviewGeometryShader;
+    vk::Bool32 multiviewTessellationShader;
   };
   static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMultiviewFeatures>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
-    {
-    protected:
-      PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this) = rhs;
-      }
-
-      PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
+  struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
   {
-    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( vk::Bool32 perViewPositionAllComponents_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : perViewPositionAllComponents( perViewPositionAllComponents_ )
     {}
 
+    vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & operator=( vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *>(&rhs);
       return *this;
     }
 
@@ -50114,53 +46333,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+    void* pNext = nullptr;
+    vk::Bool32 perViewPositionAllComponents;
   };
   static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceMultiviewProperties
   {
-    struct PhysicalDeviceMultiviewProperties
-    {
-    protected:
-      PhysicalDeviceMultiviewProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this) = rhs;
-      }
-
-      PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    PhysicalDeviceMultiviewProperties() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMultiviewProperties()
+    PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = 0,
+                                       uint32_t maxMultiviewInstanceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxMultiviewViewCount( maxMultiviewViewCount_ )
+      , maxMultiviewInstanceIndex( maxMultiviewInstanceIndex_ )
     {}
 
+    vk::PhysicalDeviceMultiviewProperties & operator=( vk::PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceMultiviewProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceMultiviewProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceMultiviewProperties const *>(&rhs);
       return *this;
     }
 
@@ -50187,55 +46389,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceMultiviewProperties::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties;
+    void* pNext = nullptr;
+    uint32_t maxMultiviewViewCount;
+    uint32_t maxMultiviewInstanceIndex;
   };
   static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceMultiviewProperties>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDevicePCIBusInfoPropertiesEXT
-    {
-    protected:
-      PhysicalDevicePCIBusInfoPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDevicePCIBusInfoPropertiesEXT
   {
-    PhysicalDevicePCIBusInfoPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevicePCIBusInfoPropertiesEXT()
+    PhysicalDevicePCIBusInfoPropertiesEXT( uint32_t pciDomain_ = 0,
+                                           uint32_t pciBus_ = 0,
+                                           uint32_t pciDevice_ = 0,
+                                           uint32_t pciFunction_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : pciDomain( pciDomain_ )
+      , pciBus( pciBus_ )
+      , pciDevice( pciDevice_ )
+      , pciFunction( pciFunction_ )
     {}
 
+    vk::PhysicalDevicePCIBusInfoPropertiesEXT & operator=( vk::PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePCIBusInfoPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevicePCIBusInfoPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDevicePCIBusInfoPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDevicePCIBusInfoPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -50264,53 +46452,165 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDevicePCIBusInfoPropertiesEXT::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePCIBusInfoPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDevicePerformanceQueryFeaturesKHR
   {
-    struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( vk::Bool32 performanceCounterQueryPools_ = 0,
+                                                                    vk::Bool32 performanceCounterMultipleQueryPools_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : performanceCounterQueryPools( performanceCounterQueryPools_ )
+      , performanceCounterMultipleQueryPools( performanceCounterMultipleQueryPools_ )
+    {}
+
+    vk::PhysicalDevicePerformanceQueryFeaturesKHR & operator=( vk::PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : pipelineExecutableInfo( pipelineExecutableInfo_ )
-      {}
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePerformanceQueryFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
-      PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
-      }
+    PhysicalDevicePerformanceQueryFeaturesKHR( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
 
-      PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
-        return *this;
-      }
+    PhysicalDevicePerformanceQueryFeaturesKHR& operator=( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<vk::PhysicalDevicePerformanceQueryFeaturesKHR const *>(&rhs);
+      return *this;
+    }
 
-    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!" );
-  }
+    PhysicalDevicePerformanceQueryFeaturesKHR & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDevicePerformanceQueryFeaturesKHR & setPerformanceCounterQueryPools( vk::Bool32 performanceCounterQueryPools_ ) VULKAN_HPP_NOEXCEPT
+    {
+      performanceCounterQueryPools = performanceCounterQueryPools_;
+      return *this;
+    }
+
+    PhysicalDevicePerformanceQueryFeaturesKHR & setPerformanceCounterMultipleQueryPools( vk::Bool32 performanceCounterMultipleQueryPools_ ) VULKAN_HPP_NOEXCEPT
+    {
+      performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools_;
+      return *this;
+    }
+
+    operator VkPhysicalDevicePerformanceQueryFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>( this );
+    }
+
+    operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>( this );
+    }
+
+    bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( performanceCounterQueryPools == rhs.performanceCounterQueryPools )
+          && ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools );
+    }
+
+    bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 performanceCounterQueryPools;
+    vk::Bool32 performanceCounterMultipleQueryPools;
+  };
+  static_assert( sizeof( PhysicalDevicePerformanceQueryFeaturesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryFeaturesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDevicePerformanceQueryFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+  struct PhysicalDevicePerformanceQueryPropertiesKHR
+  {
+    PhysicalDevicePerformanceQueryPropertiesKHR( vk::Bool32 allowCommandBufferQueryCopies_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : allowCommandBufferQueryCopies( allowCommandBufferQueryCopies_ )
+    {}
+
+    vk::PhysicalDevicePerformanceQueryPropertiesKHR & operator=( vk::PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePerformanceQueryPropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
+    PhysicalDevicePerformanceQueryPropertiesKHR( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+    PhysicalDevicePerformanceQueryPropertiesKHR& operator=( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<vk::PhysicalDevicePerformanceQueryPropertiesKHR const *>(&rhs);
+      return *this;
+    }
+
+    operator VkPhysicalDevicePerformanceQueryPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>( this );
+    }
+
+    operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>( this );
+    }
+
+    bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies );
+    }
+
+    bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 allowCommandBufferQueryCopies;
+  };
+  static_assert( sizeof( PhysicalDevicePerformanceQueryPropertiesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryPropertiesKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDevicePerformanceQueryPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR : public layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
+  struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( pipelineExecutableInfo_ )
+      : pipelineExecutableInfo( pipelineExecutableInfo_ )
     {}
 
+    vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & operator=( vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -50348,52 +46648,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 pipelineExecutableInfo;
   };
   static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDevicePointClippingProperties
-    {
-    protected:
-      PhysicalDevicePointClippingProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this) = rhs;
-      }
-
-      PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDevicePointClippingProperties
   {
-    PhysicalDevicePointClippingProperties() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevicePointClippingProperties()
+    PhysicalDevicePointClippingProperties( vk::PointClippingBehavior pointClippingBehavior_ = vk::PointClippingBehavior::eAllClipPlanes ) VULKAN_HPP_NOEXCEPT
+      : pointClippingBehavior( pointClippingBehavior_ )
     {}
 
+    vk::PhysicalDevicePointClippingProperties & operator=( vk::PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePointClippingProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevicePointClippingProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDevicePointClippingProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDevicePointClippingProperties const *>(&rhs);
       return *this;
     }
 
@@ -50419,25 +46701,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDevicePointClippingProperties::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
+    void* pNext = nullptr;
+    vk::PointClippingBehavior pointClippingBehavior;
   };
   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
   {
-    PhysicalDeviceSparseProperties() VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceSparseProperties( vk::Bool32 residencyStandard2DBlockShape_ = 0,
+                                    vk::Bool32 residencyStandard2DMultisampleBlockShape_ = 0,
+                                    vk::Bool32 residencyStandard3DBlockShape_ = 0,
+                                    vk::Bool32 residencyAlignedMipSize_ = 0,
+                                    vk::Bool32 residencyNonResidentStrict_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : residencyStandard2DBlockShape( residencyStandard2DBlockShape_ )
+      , residencyStandard2DMultisampleBlockShape( residencyStandard2DMultisampleBlockShape_ )
+      , residencyStandard3DBlockShape( residencyStandard3DBlockShape_ )
+      , residencyAlignedMipSize( residencyAlignedMipSize_ )
+      , residencyNonResidentStrict( residencyNonResidentStrict_ )
     {}
 
     PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     PhysicalDeviceSparseProperties& operator=( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PhysicalDeviceSparseProperties const *>(&rhs);
       return *this;
     }
 
@@ -50477,17 +46770,37 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceProperties
   {
-    PhysicalDeviceProperties() VULKAN_HPP_NOEXCEPT
-    {}
+    PhysicalDeviceProperties( uint32_t apiVersion_ = 0,
+                              uint32_t driverVersion_ = 0,
+                              uint32_t vendorID_ = 0,
+                              uint32_t deviceID_ = 0,
+                              vk::PhysicalDeviceType deviceType_ = vk::PhysicalDeviceType::eOther,
+                              std::array<char,VK_MAX_PHYSICAL_DEVICE_NAME_SIZE> const& deviceName_ = { { 0 } },
+                              std::array<uint8_t,VK_UUID_SIZE> const& pipelineCacheUUID_ = { { 0 } },
+                              vk::PhysicalDeviceLimits limits_ = vk::PhysicalDeviceLimits(),
+                              vk::PhysicalDeviceSparseProperties sparseProperties_ = vk::PhysicalDeviceSparseProperties() ) VULKAN_HPP_NOEXCEPT
+      : apiVersion( apiVersion_ )
+      , driverVersion( driverVersion_ )
+      , vendorID( vendorID_ )
+      , deviceID( deviceID_ )
+      , deviceType( deviceType_ )
+      , deviceName{}
+      , pipelineCacheUUID{}
+      , limits( limits_ )
+      , sparseProperties( sparseProperties_ )
+    {
+      vk::ConstExpressionArrayCopy<char,VK_MAX_PHYSICAL_DEVICE_NAME_SIZE,VK_MAX_PHYSICAL_DEVICE_NAME_SIZE>::copy( deviceName, deviceName_ );
+      vk::ConstExpressionArrayCopy<uint8_t,VK_UUID_SIZE,VK_UUID_SIZE>::copy( pipelineCacheUUID, pipelineCacheUUID_ );
+    }
 
     PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     PhysicalDeviceProperties& operator=( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPhysicalDeviceProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PhysicalDeviceProperties const *>(&rhs);
       return *this;
     }
 
@@ -50533,46 +46846,26 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceProperties2
-    {
-    protected:
-      PhysicalDeviceProperties2() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceProperties2*>(this) = rhs;
-      }
-
-      PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceProperties2
   {
-    PhysicalDeviceProperties2() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceProperties2()
+    PhysicalDeviceProperties2( vk::PhysicalDeviceProperties properties_ = vk::PhysicalDeviceProperties() ) VULKAN_HPP_NOEXCEPT
+      : properties( properties_ )
     {}
 
+    vk::PhysicalDeviceProperties2 & operator=( vk::PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProperties2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceProperties2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceProperties2::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceProperties2 const *>(&rhs);
       return *this;
     }
 
@@ -50598,53 +46891,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceProperties2::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceProperties2;
+    void* pNext = nullptr;
+    vk::PhysicalDeviceProperties properties;
   };
   static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceProperties2>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceProtectedMemoryFeatures
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : protectedMemory( protectedMemory_ )
-      {}
-
-      PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this) = rhs;
-      }
-
-      PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceProtectedMemoryFeatures
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceProtectedMemoryFeatures( protectedMemory_ )
+      : protectedMemory( protectedMemory_ )
     {}
 
+    vk::PhysicalDeviceProtectedMemoryFeatures & operator=( vk::PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProtectedMemoryFeatures ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceProtectedMemoryFeatures( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceProtectedMemoryFeatures::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceProtectedMemoryFeatures const *>(&rhs);
       return *this;
     }
 
@@ -50682,52 +46956,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceProtectedMemoryFeatures::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
+    void* pNext = nullptr;
+    vk::Bool32 protectedMemory;
   };
   static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceProtectedMemoryFeatures>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceProtectedMemoryProperties
-    {
-    protected:
-      PhysicalDeviceProtectedMemoryProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this) = rhs;
-      }
-
-      PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceProtectedMemoryProperties
+  struct PhysicalDeviceProtectedMemoryProperties
   {
-    PhysicalDeviceProtectedMemoryProperties() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceProtectedMemoryProperties()
+    PhysicalDeviceProtectedMemoryProperties( vk::Bool32 protectedNoFault_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : protectedNoFault( protectedNoFault_ )
     {}
 
+    vk::PhysicalDeviceProtectedMemoryProperties & operator=( vk::PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProtectedMemoryProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceProtectedMemoryProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceProtectedMemoryProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceProtectedMemoryProperties const *>(&rhs);
       return *this;
     }
 
@@ -50753,52 +47009,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceProtectedMemoryProperties::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
+    void* pNext = nullptr;
+    vk::Bool32 protectedNoFault;
   };
   static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceProtectedMemoryProperties>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDevicePushDescriptorPropertiesKHR
   {
-    struct PhysicalDevicePushDescriptorPropertiesKHR
-    {
-    protected:
-      PhysicalDevicePushDescriptorPropertiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this) = rhs;
-      }
-
-      PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDevicePushDescriptorPropertiesKHR
-  {
-    PhysicalDevicePushDescriptorPropertiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevicePushDescriptorPropertiesKHR()
+    PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxPushDescriptors( maxPushDescriptors_ )
     {}
 
+    vk::PhysicalDevicePushDescriptorPropertiesKHR & operator=( vk::PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePushDescriptorPropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDevicePushDescriptorPropertiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDevicePushDescriptorPropertiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDevicePushDescriptorPropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -50824,59 +47062,48 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDevicePushDescriptorPropertiesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
+    void* pNext = nullptr;
+    uint32_t maxPushDescriptors;
   };
   static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDevicePushDescriptorPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceRayTracingPropertiesNV
   {
-    struct PhysicalDeviceRayTracingPropertiesNV
-    {
-    protected:
-      PhysicalDeviceRayTracingPropertiesNV() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceRayTracingPropertiesNV
-  {
-    PhysicalDeviceRayTracingPropertiesNV() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceRayTracingPropertiesNV()
+    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 ) VULKAN_HPP_NOEXCEPT
+      : shaderGroupHandleSize( shaderGroupHandleSize_ )
+      , maxRecursionDepth( maxRecursionDepth_ )
+      , maxShaderGroupStride( maxShaderGroupStride_ )
+      , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ )
+      , maxGeometryCount( maxGeometryCount_ )
+      , maxInstanceCount( maxInstanceCount_ )
+      , maxTriangleCount( maxTriangleCount_ )
+      , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ )
     {}
 
+    vk::PhysicalDeviceRayTracingPropertiesNV & operator=( vk::PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceRayTracingPropertiesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceRayTracingPropertiesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceRayTracingPropertiesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceRayTracingPropertiesNV const *>(&rhs);
       return *this;
     }
 
@@ -50909,53 +47136,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceRayTracingPropertiesNV::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : representativeFragmentTest( representativeFragmentTest_ )
-      {}
-
-      PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV
+  struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( representativeFragmentTest_ )
+      : representativeFragmentTest( representativeFragmentTest_ )
     {}
 
+    vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=( vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -50993,56 +47208,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 representativeFragmentTest;
   };
   static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceRepresentativeFragmentTestFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceSampleLocationsPropertiesEXT
   {
-    struct PhysicalDeviceSampleLocationsPropertiesEXT
+    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 ) VULKAN_HPP_NOEXCEPT
+      : sampleLocationSampleCounts( sampleLocationSampleCounts_ )
+      , maxSampleLocationGridSize( maxSampleLocationGridSize_ )
+      , sampleLocationCoordinateRange{}
+      , sampleLocationSubPixelBits( sampleLocationSubPixelBits_ )
+      , variableSampleLocations( variableSampleLocations_ )
     {
-    protected:
-      PhysicalDeviceSampleLocationsPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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!" );
-  }
+      vk::ConstExpressionArrayCopy<float,2,2>::copy( sampleLocationCoordinateRange, sampleLocationCoordinateRange_ );
+    }
 
-  struct PhysicalDeviceSampleLocationsPropertiesEXT : public layout::PhysicalDeviceSampleLocationsPropertiesEXT
-  {
-    PhysicalDeviceSampleLocationsPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSampleLocationsPropertiesEXT()
-    {}
+    vk::PhysicalDeviceSampleLocationsPropertiesEXT & operator=( vk::PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSampleLocationsPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSampleLocationsPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSampleLocationsPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSampleLocationsPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -51072,53 +47275,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSampleLocationsPropertiesEXT::sType;
+  public:
+    const 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 ), "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
   {
-    struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT()
+    PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( vk::Bool32 filterMinmaxSingleComponentFormats_ = 0,
+                                                    vk::Bool32 filterMinmaxImageComponentMapping_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ )
+      , filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ )
     {}
 
+    vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT & operator=( vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -51145,53 +47335,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 filterMinmaxSingleComponentFormats;
+    vk::Bool32 filterMinmaxImageComponentMapping;
   };
   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!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceSamplerYcbcrConversionFeatures
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : samplerYcbcrConversion( samplerYcbcrConversion_ )
-      {}
-
-      PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this) = rhs;
-      }
-
-      PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceSamplerYcbcrConversionFeatures
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( samplerYcbcrConversion_ )
+      : samplerYcbcrConversion( samplerYcbcrConversion_ )
     {}
 
+    vk::PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( vk::PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSamplerYcbcrConversionFeatures ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSamplerYcbcrConversionFeatures::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSamplerYcbcrConversionFeatures const *>(&rhs);
       return *this;
     }
 
@@ -51229,53 +47401,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSamplerYcbcrConversionFeatures::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
+    void* pNext = nullptr;
+    vk::Bool32 samplerYcbcrConversion;
   };
   static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSamplerYcbcrConversionFeatures>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceScalarBlockLayoutFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : scalarBlockLayout( scalarBlockLayout_ )
-      {}
-
-      PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceScalarBlockLayoutFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( scalarBlockLayout_ )
+      : scalarBlockLayout( scalarBlockLayout_ )
     {}
 
+    vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT & operator=( vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -51313,53 +47466,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 scalarBlockLayout;
   };
   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!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( vk::Bool32 separateDepthStencilLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : separateDepthStencilLayouts( separateDepthStencilLayouts_ )
-      {}
-
-      PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR& operator=( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
-      void* pNext = nullptr;
-      vk::Bool32 separateDepthStencilLayouts;
-    };
-    static_assert( sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ) == sizeof( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR : public layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR
+  struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( vk::Bool32 separateDepthStencilLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( separateDepthStencilLayouts_ )
+      : separateDepthStencilLayouts( separateDepthStencilLayouts_ )
     {}
 
+    vk::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR & operator=( vk::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR& operator=( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -51397,57 +47531,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 separateDepthStencilLayouts;
   };
   static_assert( sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ) == sizeof( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0,
-                                                                       vk::Bool32 shaderSharedInt64Atomics_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
-        , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
-      {}
-
-      PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0,
                                                                      vk::Bool32 shaderSharedInt64Atomics_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( shaderBufferInt64Atomics_, shaderSharedInt64Atomics_ )
+      : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
+      , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
     {}
 
+    vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR & operator=( vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -51492,57 +47605,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 shaderBufferInt64Atomics;
+    vk::Bool32 shaderSharedInt64Atomics;
   };
   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 PhysicalDeviceShaderClockFeaturesKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( vk::Bool32 shaderSubgroupClock_ = 0,
-                                                                 vk::Bool32 shaderDeviceClock_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shaderSubgroupClock( shaderSubgroupClock_ )
-        , shaderDeviceClock( shaderDeviceClock_ )
-      {}
-
-      PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR;
-      void* pNext = nullptr;
-      vk::Bool32 shaderSubgroupClock;
-      vk::Bool32 shaderDeviceClock;
-    };
-    static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct PhysicalDeviceShaderClockFeaturesKHR : public layout::PhysicalDeviceShaderClockFeaturesKHR
+  struct PhysicalDeviceShaderClockFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( vk::Bool32 shaderSubgroupClock_ = 0,
                                                                vk::Bool32 shaderDeviceClock_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderClockFeaturesKHR( shaderSubgroupClock_, shaderDeviceClock_ )
+      : shaderSubgroupClock( shaderSubgroupClock_ )
+      , shaderDeviceClock( shaderDeviceClock_ )
     {}
 
+    vk::PhysicalDeviceShaderClockFeaturesKHR & operator=( vk::PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderClockFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderClockFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderClockFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderClockFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -51587,53 +47680,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderClockFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 shaderSubgroupClock;
+    vk::Bool32 shaderDeviceClock;
   };
   static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderClockFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderCoreProperties2AMD
-    {
-    protected:
-      PhysicalDeviceShaderCoreProperties2AMD() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceShaderCoreProperties2AMD
   {
-    PhysicalDeviceShaderCoreProperties2AMD() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderCoreProperties2AMD()
+    PhysicalDeviceShaderCoreProperties2AMD( vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = vk::ShaderCorePropertiesFlagsAMD(),
+                                            uint32_t activeComputeUnitCount_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : shaderCoreFeatures( shaderCoreFeatures_ )
+      , activeComputeUnitCount( activeComputeUnitCount_ )
     {}
 
+    vk::PhysicalDeviceShaderCoreProperties2AMD & operator=( vk::PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderCoreProperties2AMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderCoreProperties2AMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderCoreProperties2AMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderCoreProperties2AMD const *>(&rhs);
       return *this;
     }
 
@@ -51660,65 +47737,61 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderCoreProperties2AMD::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD;
+    void* pNext = nullptr;
+    vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures;
+    uint32_t activeComputeUnitCount;
   };
   static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderCoreProperties2AMD>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderCorePropertiesAMD
-    {
-    protected:
-      PhysicalDeviceShaderCorePropertiesAMD() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceShaderCorePropertiesAMD
-  {
-    PhysicalDeviceShaderCorePropertiesAMD() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderCorePropertiesAMD()
-    {}
+  struct PhysicalDeviceShaderCorePropertiesAMD
+  {
+    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 ) VULKAN_HPP_NOEXCEPT
+      : 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_ )
+    {}
+
+    vk::PhysicalDeviceShaderCorePropertiesAMD & operator=( vk::PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderCorePropertiesAMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderCorePropertiesAMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderCorePropertiesAMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderCorePropertiesAMD const *>(&rhs);
       return *this;
     }
 
@@ -51757,53 +47830,47 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderCorePropertiesAMD::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ )
-      {}
-
-      PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
+  struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( shaderDemoteToHelperInvocation_ )
+      : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ )
     {}
 
+    vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & operator=( vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -51841,53 +47908,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 shaderDemoteToHelperInvocation;
   };
   static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderDrawParametersFeatures
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shaderDrawParameters( shaderDrawParameters_ )
-      {}
-
-      PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PhysicalDeviceShaderDrawParametersFeatures
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderDrawParametersFeatures( shaderDrawParameters_ )
+      : shaderDrawParameters( shaderDrawParameters_ )
     {}
 
+    vk::PhysicalDeviceShaderDrawParametersFeatures & operator=( vk::PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderDrawParametersFeatures ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderDrawParametersFeatures( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderDrawParametersFeatures::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderDrawParametersFeatures const *>(&rhs);
       return *this;
     }
 
@@ -51925,57 +47973,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderDrawParametersFeatures::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures;
+    void* pNext = nullptr;
+    vk::Bool32 shaderDrawParameters;
   };
   static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderDrawParametersFeatures>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderFloat16Int8FeaturesKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0,
-                                                                       vk::Bool32 shaderInt8_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shaderFloat16( shaderFloat16_ )
-        , shaderInt8( shaderInt8_ )
-      {}
-
-      PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceShaderFloat16Int8FeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0,
                                                                      vk::Bool32 shaderInt8_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( shaderFloat16_, shaderInt8_ )
+      : shaderFloat16( shaderFloat16_ )
+      , shaderInt8( shaderInt8_ )
     {}
 
+    vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR & operator=( vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -52020,53 +48047,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 shaderFloat16;
+    vk::Bool32 shaderInt8;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : imageFootprint( imageFootprint_ )
-      {}
-
-      PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceShaderImageFootprintFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( imageFootprint_ )
+      : imageFootprint( imageFootprint_ )
     {}
 
+    vk::PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( vk::PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderImageFootprintFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderImageFootprintFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderImageFootprintFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -52104,53 +48113,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderImageFootprintFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 imageFootprint;
   };
   static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderImageFootprintFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shaderIntegerFunctions2( shaderIntegerFunctions2_ )
-      {}
-
-      PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : public layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
+  struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( shaderIntegerFunctions2_ )
+      : shaderIntegerFunctions2( shaderIntegerFunctions2_ )
     {}
 
+    vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & operator=( vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *>(&rhs);
       return *this;
     }
 
@@ -52188,53 +48178,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
+    void* pNext = nullptr;
+    vk::Bool32 shaderIntegerFunctions2;
   };
   static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shaderSMBuiltins( shaderSMBuiltins_ )
-      {}
-
-      PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( shaderSMBuiltins_ )
+      : shaderSMBuiltins( shaderSMBuiltins_ )
     {}
 
+    vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -52272,53 +48243,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 shaderSMBuiltins;
   };
   static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderSMBuiltinsFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
-    {
-    protected:
-      PhysicalDeviceShaderSMBuiltinsPropertiesNV() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
   {
-    PhysicalDeviceShaderSMBuiltinsPropertiesNV() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV()
+    PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = 0,
+                                                uint32_t shaderWarpsPerSM_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : shaderSMCount( shaderSMCount_ )
+      , shaderWarpsPerSM( shaderWarpsPerSM_ )
     {}
 
+    vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV const *>(&rhs);
       return *this;
     }
 
@@ -52345,53 +48299,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV;
+    void* pNext = nullptr;
+    uint32_t shaderSMCount;
+    uint32_t shaderWarpsPerSM;
   };
   static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderSMBuiltinsPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( vk::Bool32 shaderSubgroupExtendedTypes_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ )
-      {}
-
-      PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
-      void* pNext = nullptr;
-      vk::Bool32 shaderSubgroupExtendedTypes;
-    };
-    static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR : public layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR
+  struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( vk::Bool32 shaderSubgroupExtendedTypes_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( shaderSubgroupExtendedTypes_ )
+      : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ )
     {}
 
+    vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR & operator=( vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -52429,57 +48365,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 shaderSubgroupExtendedTypes;
   };
   static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShadingRateImageFeaturesNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0,
-                                                                     vk::Bool32 shadingRateCoarseSampleOrder_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : shadingRateImage( shadingRateImage_ )
-        , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
-      {}
-
-      PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceShadingRateImageFeaturesNV
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0,
                                                                    vk::Bool32 shadingRateCoarseSampleOrder_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShadingRateImageFeaturesNV( shadingRateImage_, shadingRateCoarseSampleOrder_ )
+      : shadingRateImage( shadingRateImage_ )
+      , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
     {}
 
+    vk::PhysicalDeviceShadingRateImageFeaturesNV & operator=( vk::PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShadingRateImageFeaturesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShadingRateImageFeaturesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShadingRateImageFeaturesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShadingRateImageFeaturesNV const *>(&rhs);
       return *this;
     }
 
@@ -52524,54 +48439,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShadingRateImageFeaturesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
+    void* pNext = nullptr;
+    vk::Bool32 shadingRateImage;
+    vk::Bool32 shadingRateCoarseSampleOrder;
   };
   static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShadingRateImageFeaturesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceShadingRateImagePropertiesNV
-    {
-    protected:
-      PhysicalDeviceShadingRateImagePropertiesNV() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this) = rhs;
-      }
-
-      PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceShadingRateImagePropertiesNV
   {
-    PhysicalDeviceShadingRateImagePropertiesNV() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShadingRateImagePropertiesNV()
+    PhysicalDeviceShadingRateImagePropertiesNV( vk::Extent2D shadingRateTexelSize_ = vk::Extent2D(),
+                                                uint32_t shadingRatePaletteSize_ = 0,
+                                                uint32_t shadingRateMaxCoarseSamples_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : shadingRateTexelSize( shadingRateTexelSize_ )
+      , shadingRatePaletteSize( shadingRatePaletteSize_ )
+      , shadingRateMaxCoarseSamples( shadingRateMaxCoarseSamples_ )
     {}
 
+    vk::PhysicalDeviceShadingRateImagePropertiesNV & operator=( vk::PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShadingRateImagePropertiesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceShadingRateImagePropertiesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceShadingRateImagePropertiesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceShadingRateImagePropertiesNV const *>(&rhs);
       return *this;
     }
 
@@ -52599,69 +48499,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceShadingRateImagePropertiesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
+    void* pNext = nullptr;
+    vk::Extent2D shadingRateTexelSize;
+    uint32_t shadingRatePaletteSize;
+    uint32_t shadingRateMaxCoarseSamples;
   };
   static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceShadingRateImagePropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceSparseImageFormatInfo2
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : format( format_ )
-        , type( type_ )
-        , samples( samples_ )
-        , usage( usage_ )
-        , tiling( tiling_ )
-      {}
-
-      PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this) = rhs;
-      }
-
-      PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceSparseImageFormatInfo2
   {
     VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSparseImageFormatInfo2( format_, type_, samples_, usage_, tiling_ )
+      : format( format_ )
+      , type( type_ )
+      , samples( samples_ )
+      , usage( usage_ )
+      , tiling( tiling_ )
     {}
 
+    vk::PhysicalDeviceSparseImageFormatInfo2 & operator=( vk::PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSparseImageFormatInfo2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSparseImageFormatInfo2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSparseImageFormatInfo2::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSparseImageFormatInfo2 const *>(&rhs);
       return *this;
     }
 
@@ -52727,55 +48602,44 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSparseImageFormatInfo2::sType;
+  public:
+    const 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 ), "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
   {
-    struct PhysicalDeviceSubgroupProperties
-    {
-    protected:
-      PhysicalDeviceSubgroupProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this) = rhs;
-      }
-
-      PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceSubgroupProperties
-  {
-    PhysicalDeviceSubgroupProperties() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSubgroupProperties()
+    PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = 0,
+                                      vk::ShaderStageFlags supportedStages_ = vk::ShaderStageFlags(),
+                                      vk::SubgroupFeatureFlags supportedOperations_ = vk::SubgroupFeatureFlags(),
+                                      vk::Bool32 quadOperationsInAllStages_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : subgroupSize( subgroupSize_ )
+      , supportedStages( supportedStages_ )
+      , supportedOperations( supportedOperations_ )
+      , quadOperationsInAllStages( quadOperationsInAllStages_ )
     {}
 
+    vk::PhysicalDeviceSubgroupProperties & operator=( vk::PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSubgroupProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSubgroupProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSubgroupProperties const *>(&rhs);
       return *this;
     }
 
@@ -52804,57 +48668,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSubgroupProperties::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0,
-                                                                         vk::Bool32 computeFullSubgroups_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : subgroupSizeControl( subgroupSizeControl_ )
-        , computeFullSubgroups( computeFullSubgroups_ )
-      {}
-
-      PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 PhysicalDeviceSubgroupSizeControlFeaturesEXT : public layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT
+  struct PhysicalDeviceSubgroupSizeControlFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0,
                                                                        vk::Bool32 computeFullSubgroups_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( subgroupSizeControl_, computeFullSubgroups_ )
+      : subgroupSizeControl( subgroupSizeControl_ )
+      , computeFullSubgroups( computeFullSubgroups_ )
     {}
 
+    vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT & operator=( vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -52899,55 +48745,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 subgroupSizeControl;
+    vk::Bool32 computeFullSubgroups;
   };
   static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSubgroupSizeControlFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceSubgroupSizeControlPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
   {
-    PhysicalDeviceSubgroupSizeControlPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT()
+    PhysicalDeviceSubgroupSizeControlPropertiesEXT( uint32_t minSubgroupSize_ = 0,
+                                                    uint32_t maxSubgroupSize_ = 0,
+                                                    uint32_t maxComputeWorkgroupSubgroups_ = 0,
+                                                    vk::ShaderStageFlags requiredSubgroupSizeStages_ = vk::ShaderStageFlags() ) VULKAN_HPP_NOEXCEPT
+      : minSubgroupSize( minSubgroupSize_ )
+      , maxSubgroupSize( maxSubgroupSize_ )
+      , maxComputeWorkgroupSubgroups( maxComputeWorkgroupSubgroups_ )
+      , requiredSubgroupSizeStages( requiredSubgroupSizeStages_ )
     {}
 
+    vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT & operator=( vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -52976,53 +48808,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() ) VULKAN_HPP_NOEXCEPT
-        : surface( surface_ )
-      {}
-
-      PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceSurfaceInfo2KHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSurfaceInfo2KHR( surface_ )
+      : surface( surface_ )
     {}
 
+    vk::PhysicalDeviceSurfaceInfo2KHR & operator=( vk::PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSurfaceInfo2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceSurfaceInfo2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceSurfaceInfo2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceSurfaceInfo2KHR const *>(&rhs);
       return *this;
     }
 
@@ -53060,53 +48876,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceSurfaceInfo2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
+    const void* pNext = nullptr;
+    vk::SurfaceKHR surface;
   };
   static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceSurfaceInfo2KHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : texelBufferAlignment( texelBufferAlignment_ )
-      {}
-
-      PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( texelBufferAlignment_ )
+      : texelBufferAlignment( texelBufferAlignment_ )
     {}
 
+    vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -53144,55 +48941,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 texelBufferAlignment;
   };
   static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTexelBufferAlignmentFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceTexelBufferAlignmentPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
   {
-    PhysicalDeviceTexelBufferAlignmentPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT()
+    PhysicalDeviceTexelBufferAlignmentPropertiesEXT( vk::DeviceSize storageTexelBufferOffsetAlignmentBytes_ = 0,
+                                                     vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = 0,
+                                                     vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = 0,
+                                                     vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : storageTexelBufferOffsetAlignmentBytes( storageTexelBufferOffsetAlignmentBytes_ )
+      , storageTexelBufferOffsetSingleTexelAlignment( storageTexelBufferOffsetSingleTexelAlignment_ )
+      , uniformTexelBufferOffsetAlignmentBytes( uniformTexelBufferOffsetAlignmentBytes_ )
+      , uniformTexelBufferOffsetSingleTexelAlignment( uniformTexelBufferOffsetSingleTexelAlignment_ )
     {}
 
+    vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT & operator=( vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -53221,57 +49003,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ )
-      {}
-
-      PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( textureCompressionASTC_HDR_ )
+      : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ )
     {}
 
+    vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & operator=( vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *>(&rhs);
       return *this;
     }
 
-    PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
       return *this;
@@ -53305,53 +49071,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 textureCompressionASTC_HDR;
   };
   static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceTimelineSemaphoreFeaturesKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeaturesKHR( vk::Bool32 timelineSemaphore_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : timelineSemaphore( timelineSemaphore_ )
-      {}
-
-      PhysicalDeviceTimelineSemaphoreFeaturesKHR( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeaturesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeaturesKHR;
-      void* pNext = nullptr;
-      vk::Bool32 timelineSemaphore;
-    };
-    static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeaturesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct PhysicalDeviceTimelineSemaphoreFeaturesKHR : public layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR
+  struct PhysicalDeviceTimelineSemaphoreFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeaturesKHR( vk::Bool32 timelineSemaphore_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR( timelineSemaphore_ )
+      : timelineSemaphore( timelineSemaphore_ )
     {}
 
+    vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR & operator=( vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceTimelineSemaphoreFeaturesKHR( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -53389,52 +49136,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 timelineSemaphore;
   };
   static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeaturesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTimelineSemaphoreFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceTimelineSemaphorePropertiesKHR
-    {
-    protected:
-      PhysicalDeviceTimelineSemaphorePropertiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceTimelineSemaphorePropertiesKHR( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTimelineSemaphorePropertiesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTimelineSemaphorePropertiesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphorePropertiesKHR;
-      void* pNext = nullptr;
-      uint64_t maxTimelineSemaphoreValueDifference;
-    };
-    static_assert( sizeof( PhysicalDeviceTimelineSemaphorePropertiesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphorePropertiesKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct PhysicalDeviceTimelineSemaphorePropertiesKHR : public layout::PhysicalDeviceTimelineSemaphorePropertiesKHR
+  struct PhysicalDeviceTimelineSemaphorePropertiesKHR
   {
-    PhysicalDeviceTimelineSemaphorePropertiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTimelineSemaphorePropertiesKHR()
+    PhysicalDeviceTimelineSemaphorePropertiesKHR( uint64_t maxTimelineSemaphoreValueDifference_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ )
     {}
 
+    vk::PhysicalDeviceTimelineSemaphorePropertiesKHR & operator=( vk::PhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTimelineSemaphorePropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceTimelineSemaphorePropertiesKHR( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTimelineSemaphorePropertiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceTimelineSemaphorePropertiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceTimelineSemaphorePropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -53460,57 +49189,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceTimelineSemaphorePropertiesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphorePropertiesKHR;
+    void* pNext = nullptr;
+    uint64_t maxTimelineSemaphoreValueDifference;
   };
   static_assert( sizeof( PhysicalDeviceTimelineSemaphorePropertiesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphorePropertiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTimelineSemaphorePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceTransformFeedbackFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0,
-                                                                       vk::Bool32 geometryStreams_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : transformFeedback( transformFeedback_ )
-        , geometryStreams( geometryStreams_ )
-      {}
-
-      PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceTransformFeedbackFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0,
                                                                      vk::Bool32 geometryStreams_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( transformFeedback_, geometryStreams_ )
+      : transformFeedback( transformFeedback_ )
+      , geometryStreams( geometryStreams_ )
     {}
 
+    vk::PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( vk::PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTransformFeedbackFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceTransformFeedbackFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceTransformFeedbackFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -53555,61 +49263,53 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceTransformFeedbackFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 transformFeedback;
+    vk::Bool32 geometryStreams;
   };
   static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceTransformFeedbackFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceTransformFeedbackPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceTransformFeedbackPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PhysicalDeviceTransformFeedbackPropertiesEXT
   {
-    PhysicalDeviceTransformFeedbackPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTransformFeedbackPropertiesEXT()
+    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 ) VULKAN_HPP_NOEXCEPT
+      : maxTransformFeedbackStreams( maxTransformFeedbackStreams_ )
+      , maxTransformFeedbackBuffers( maxTransformFeedbackBuffers_ )
+      , maxTransformFeedbackBufferSize( maxTransformFeedbackBufferSize_ )
+      , maxTransformFeedbackStreamDataSize( maxTransformFeedbackStreamDataSize_ )
+      , maxTransformFeedbackBufferDataSize( maxTransformFeedbackBufferDataSize_ )
+      , maxTransformFeedbackBufferDataStride( maxTransformFeedbackBufferDataStride_ )
+      , transformFeedbackQueries( transformFeedbackQueries_ )
+      , transformFeedbackStreamsLinesTriangles( transformFeedbackStreamsLinesTriangles_ )
+      , transformFeedbackRasterizationStreamSelect( transformFeedbackRasterizationStreamSelect_ )
+      , transformFeedbackDraw( transformFeedbackDraw_ )
     {}
 
+    vk::PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( vk::PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTransformFeedbackPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceTransformFeedbackPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceTransformFeedbackPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceTransformFeedbackPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -53644,53 +49344,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceTransformFeedbackPropertiesEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : uniformBufferStandardLayout( uniformBufferStandardLayout_ )
-      {}
-
-      PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( uniformBufferStandardLayout_ )
+      : uniformBufferStandardLayout( uniformBufferStandardLayout_ )
     {}
 
+    vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & operator=( vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -53728,57 +49418,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 uniformBufferStandardLayout;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0,
-                                                                   vk::Bool32 variablePointers_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
-        , variablePointers( variablePointers_ )
-      {}
-
-      PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(this) = rhs;
-      }
-
-      PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PhysicalDeviceVariablePointersFeatures
+  struct PhysicalDeviceVariablePointersFeatures
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0,
                                                                  vk::Bool32 variablePointers_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceVariablePointersFeatures( variablePointersStorageBuffer_, variablePointers_ )
+      : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
+      , variablePointers( variablePointers_ )
     {}
 
+    vk::PhysicalDeviceVariablePointersFeatures & operator=( vk::PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVariablePointersFeatures ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceVariablePointersFeatures( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceVariablePointersFeatures::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceVariablePointersFeatures const *>(&rhs);
       return *this;
     }
 
@@ -53823,57 +49492,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceVariablePointersFeatures::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures;
+    void* pNext = nullptr;
+    vk::Bool32 variablePointersStorageBuffer;
+    vk::Bool32 variablePointers;
   };
   static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVariablePointersFeatures>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0,
-                                                                            vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
-        , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
-      {}
-
-      PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0,
                                                                           vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vertexAttributeInstanceRateDivisor_, vertexAttributeInstanceRateZeroDivisor_ )
+      : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
+      , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
     {}
 
+    vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT & operator=( vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -53918,52 +49567,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 vertexAttributeInstanceRateDivisor;
+    vk::Bool32 vertexAttributeInstanceRateZeroDivisor;
   };
   static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVertexAttributeDivisorFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
   {
-    struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
-    {
-    protected:
-      PhysicalDeviceVertexAttributeDivisorPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    PhysicalDeviceVertexAttributeDivisorPropertiesEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT()
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : maxVertexAttribDivisor( maxVertexAttribDivisor_ )
     {}
 
+    vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=( vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const *>(&rhs);
       return *this;
     }
 
@@ -53989,61 +49621,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+    void* pNext = nullptr;
+    uint32_t maxVertexAttribDivisor;
   };
   static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0,
-                                                                       vk::Bool32 vulkanMemoryModelDeviceScope_ = 0,
-                                                                       vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : vulkanMemoryModel( vulkanMemoryModel_ )
-        , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ )
-        , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ )
-      {}
-
-      PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this) = rhs;
-      }
-
-      PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0,
                                                                      vk::Bool32 vulkanMemoryModelDeviceScope_ = 0,
                                                                      vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( vulkanMemoryModel_, vulkanMemoryModelDeviceScope_, vulkanMemoryModelAvailabilityVisibilityChains_ )
+      : vulkanMemoryModel( vulkanMemoryModel_ )
+      , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ )
+      , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ )
     {}
 
+    vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR & operator=( vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR const *>(&rhs);
       return *this;
     }
 
@@ -54095,53 +49704,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR;
+    void* pNext = nullptr;
+    vk::Bool32 vulkanMemoryModel;
+    vk::Bool32 vulkanMemoryModelDeviceScope;
+    vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : ycbcrImageArrays( ycbcrImageArrays_ )
-      {}
-
-      PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this) = rhs;
-      }
-
-      PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( ycbcrImageArrays_ )
+      : ycbcrImageArrays( ycbcrImageArrays_ )
     {}
 
+    vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -54179,61 +49771,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT;
+    void* pNext = nullptr;
+    vk::Bool32 ycbcrImageArrays;
   };
   static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PhysicalDeviceYcbcrImageArraysFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineCacheCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(),
-                                                    size_t initialDataSize_ = 0,
-                                                    const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , initialDataSize( initialDataSize_ )
-        , pInitialData( pInitialData_ )
-      {}
-
-      PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineCacheCreateInfo*>(this) = rhs;
-      }
-
-      PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineCacheCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(),
                                                   size_t initialDataSize_ = 0,
                                                   const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCacheCreateInfo( flags_, initialDataSize_, pInitialData_ )
+      : flags( flags_ )
+      , initialDataSize( initialDataSize_ )
+      , pInitialData( pInitialData_ )
     {}
 
+    vk::PipelineCacheCreateInfo & operator=( vk::PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCacheCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCacheCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineCacheCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineCacheCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -54285,61 +49854,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineCacheCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineCacheCreateInfo;
+    const void* pNext = nullptr;
+    vk::PipelineCacheCreateFlags flags;
+    size_t initialDataSize;
+    const void* pInitialData;
   };
   static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCacheCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineColorBlendAdvancedStateCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0,
-                                                                         vk::Bool32 dstPremultiplied_ = 0,
-                                                                         vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated ) VULKAN_HPP_NOEXCEPT
-        : srcPremultiplied( srcPremultiplied_ )
-        , dstPremultiplied( dstPremultiplied_ )
-        , blendOverlap( blendOverlap_ )
-      {}
-
-      PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineColorBlendAdvancedStateCreateInfoEXT
+  struct PipelineColorBlendAdvancedStateCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0,
                                                                        vk::Bool32 dstPremultiplied_ = 0,
                                                                        vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( srcPremultiplied_, dstPremultiplied_, blendOverlap_ )
+      : srcPremultiplied( srcPremultiplied_ )
+      , dstPremultiplied( dstPremultiplied_ )
+      , blendOverlap( blendOverlap_ )
     {}
 
+    vk::PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( vk::PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineColorBlendAdvancedStateCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineColorBlendAdvancedStateCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineColorBlendAdvancedStateCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -54391,53 +49939,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineColorBlendAdvancedStateCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::Bool32 srcPremultiplied;
+    vk::Bool32 dstPremultiplied;
+    vk::BlendOverlapEXT blendOverlap;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() ) VULKAN_HPP_NOEXCEPT
-        : compilerControlFlags( compilerControlFlags_ )
-      {}
-
-      PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(this) = rhs;
-      }
-
-      PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineCompilerControlCreateInfoAMD
   {
     VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCompilerControlCreateInfoAMD( compilerControlFlags_ )
+      : compilerControlFlags( compilerControlFlags_ )
     {}
 
+    vk::PipelineCompilerControlCreateInfoAMD & operator=( vk::PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCompilerControlCreateInfoAMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCompilerControlCreateInfoAMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineCompilerControlCreateInfoAMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineCompilerControlCreateInfoAMD const *>(&rhs);
       return *this;
     }
 
@@ -54475,69 +50006,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineCompilerControlCreateInfoAMD::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD;
+    const void* pNext = nullptr;
+    vk::PipelineCompilerControlFlagsAMD compilerControlFlags;
   };
   static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCompilerControlCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineCoverageModulationStateCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(),
-                                                                        vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone,
-                                                                        vk::Bool32 coverageModulationTableEnable_ = 0,
-                                                                        uint32_t coverageModulationTableCount_ = 0,
-                                                                        const float* pCoverageModulationTable_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , coverageModulationMode( coverageModulationMode_ )
-        , coverageModulationTableEnable( coverageModulationTableEnable_ )
-        , coverageModulationTableCount( coverageModulationTableCount_ )
-        , pCoverageModulationTable( pCoverageModulationTable_ )
-      {}
-
-      PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineCoverageModulationStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(),
                                                                       vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone,
                                                                       vk::Bool32 coverageModulationTableEnable_ = 0,
                                                                       uint32_t coverageModulationTableCount_ = 0,
                                                                       const float* pCoverageModulationTable_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCoverageModulationStateCreateInfoNV( flags_, coverageModulationMode_, coverageModulationTableEnable_, coverageModulationTableCount_, pCoverageModulationTable_ )
+      : flags( flags_ )
+      , coverageModulationMode( coverageModulationMode_ )
+      , coverageModulationTableEnable( coverageModulationTableEnable_ )
+      , coverageModulationTableCount( coverageModulationTableCount_ )
+      , pCoverageModulationTable( pCoverageModulationTable_ )
     {}
 
+    vk::PipelineCoverageModulationStateCreateInfoNV & operator=( vk::PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageModulationStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCoverageModulationStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineCoverageModulationStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineCoverageModulationStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -54603,57 +50107,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineCoverageModulationStateCreateInfoNV::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCoverageModulationStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineCoverageReductionStateCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(),
-                                                                       vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , coverageReductionMode( coverageReductionMode_ )
-      {}
-
-      PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineCoverageReductionStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(),
                                                                      vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCoverageReductionStateCreateInfoNV( flags_, coverageReductionMode_ )
+      : flags( flags_ )
+      , coverageReductionMode( coverageReductionMode_ )
     {}
 
+    vk::PipelineCoverageReductionStateCreateInfoNV & operator=( vk::PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageReductionStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCoverageReductionStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineCoverageReductionStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineCoverageReductionStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -54698,61 +50185,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineCoverageReductionStateCreateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV;
+    const void* pNext = nullptr;
+    vk::PipelineCoverageReductionStateCreateFlagsNV flags;
+    vk::CoverageReductionModeNV coverageReductionMode;
   };
   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!" );
 
-  namespace layout
-  {
-    struct PipelineCoverageToColorStateCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(),
-                                                                     vk::Bool32 coverageToColorEnable_ = 0,
-                                                                     uint32_t coverageToColorLocation_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , coverageToColorEnable( coverageToColorEnable_ )
-        , coverageToColorLocation( coverageToColorLocation_ )
-      {}
-
-      PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineCoverageToColorStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(),
                                                                    vk::Bool32 coverageToColorEnable_ = 0,
                                                                    uint32_t coverageToColorLocation_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCoverageToColorStateCreateInfoNV( flags_, coverageToColorEnable_, coverageToColorLocation_ )
+      : flags( flags_ )
+      , coverageToColorEnable( coverageToColorEnable_ )
+      , coverageToColorLocation( coverageToColorLocation_ )
     {}
 
+    vk::PipelineCoverageToColorStateCreateInfoNV & operator=( vk::PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageToColorStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCoverageToColorStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineCoverageToColorStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineCoverageToColorStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -54804,25 +50269,32 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineCoverageToColorStateCreateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
+    const void* pNext = nullptr;
+    vk::PipelineCoverageToColorStateCreateFlagsNV flags;
+    vk::Bool32 coverageToColorEnable;
+    uint32_t coverageToColorLocation;
   };
   static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCoverageToColorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
   struct PipelineCreationFeedbackEXT
   {
-    PipelineCreationFeedbackEXT() VULKAN_HPP_NOEXCEPT
+    PipelineCreationFeedbackEXT( vk::PipelineCreationFeedbackFlagsEXT flags_ = vk::PipelineCreationFeedbackFlagsEXT(),
+                                 uint64_t duration_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : flags( flags_ )
+      , duration( duration_ )
     {}
 
     PipelineCreationFeedbackEXT( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPipelineCreationFeedbackEXT*>(this) = rhs;
+      *this = rhs;
     }
 
     PipelineCreationFeedbackEXT& operator=( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPipelineCreationFeedbackEXT*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PipelineCreationFeedbackEXT const *>(&rhs);
       return *this;
     }
 
@@ -54854,55 +50326,30 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct PipelineCreationFeedbackCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr,
-                                                                  uint32_t pipelineStageCreationFeedbackCount_ = 0,
-                                                                  vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : pPipelineCreationFeedback( pPipelineCreationFeedback_ )
-        , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ )
-        , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ )
-      {}
-
-      PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineCreationFeedbackCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr,
                                                                 uint32_t pipelineStageCreationFeedbackCount_ = 0,
                                                                 vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCreationFeedbackCreateInfoEXT( pPipelineCreationFeedback_, pipelineStageCreationFeedbackCount_, pPipelineStageCreationFeedbacks_ )
+      : pPipelineCreationFeedback( pPipelineCreationFeedback_ )
+      , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ )
+      , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ )
     {}
 
+    vk::PipelineCreationFeedbackCreateInfoEXT & operator=( vk::PipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCreationFeedbackCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineCreationFeedbackCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineCreationFeedbackCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineCreationFeedbackCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -54954,65 +50401,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineCreationFeedbackCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback;
+    uint32_t pipelineStageCreationFeedbackCount;
+    vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks;
   };
   static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineCreationFeedbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineDiscardRectangleStateCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(),
-                                                                       vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive,
-                                                                       uint32_t discardRectangleCount_ = 0,
-                                                                       const vk::Rect2D* pDiscardRectangles_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , discardRectangleMode( discardRectangleMode_ )
-        , discardRectangleCount( discardRectangleCount_ )
-        , pDiscardRectangles( pDiscardRectangles_ )
-      {}
-
-      PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PipelineDiscardRectangleStateCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(),
                                                                      vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive,
                                                                      uint32_t discardRectangleCount_ = 0,
                                                                      const vk::Rect2D* pDiscardRectangles_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineDiscardRectangleStateCreateInfoEXT( flags_, discardRectangleMode_, discardRectangleCount_, pDiscardRectangles_ )
+      : flags( flags_ )
+      , discardRectangleMode( discardRectangleMode_ )
+      , discardRectangleCount( discardRectangleCount_ )
+      , pDiscardRectangles( pDiscardRectangles_ )
     {}
 
+    vk::PipelineDiscardRectangleStateCreateInfoEXT & operator=( vk::PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDiscardRectangleStateCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineDiscardRectangleStateCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineDiscardRectangleStateCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineDiscardRectangleStateCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -55071,57 +50495,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineDiscardRectangleStateCreateInfoEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(),
-                                                      uint32_t executableIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : pipeline( pipeline_ )
-        , executableIndex( executableIndex_ )
-      {}
-
-      PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineExecutableInfoKHR*>(this) = rhs;
-      }
-
-      PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineExecutableInfoKHR
   {
     VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(),
                                                     uint32_t executableIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineExecutableInfoKHR( pipeline_, executableIndex_ )
+      : pipeline( pipeline_ )
+      , executableIndex( executableIndex_ )
     {}
 
+    vk::PipelineExecutableInfoKHR & operator=( vk::PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineExecutableInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineExecutableInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineExecutableInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -55166,72 +50572,46 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineExecutableInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineExecutableInfoKHR;
+    const void* pNext = nullptr;
+    vk::Pipeline pipeline;
+    uint32_t executableIndex;
   };
   static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineExecutableInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineExecutableInternalRepresentationKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR_14 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 ) VULKAN_HPP_NOEXCEPT
-        : name{}
-        , description{}
-        , isText( isText_ )
-        , dataSize( dataSize_ )
-        , pData( pData_ )
-      {
-        vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
-        vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
-      }
-
-      PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this) = rhs;
-      }
-
-      PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineExecutableInternalRepresentationKHR
   {
     VULKAN_HPP_CONSTEXPR_14 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 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineExecutableInternalRepresentationKHR( name_, description_, isText_, dataSize_, pData_ )
-    {}
+      : name{}
+      , description{}
+      , isText( isText_ )
+      , dataSize( dataSize_ )
+      , pData( pData_ )
+    {
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+    }
+
+    vk::PipelineExecutableInternalRepresentationKHR & operator=( vk::PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableInternalRepresentationKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineExecutableInternalRepresentationKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineExecutableInternalRepresentationKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineExecutableInternalRepresentationKHR const *>(&rhs);
       return *this;
     }
 
@@ -55297,55 +50677,47 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineExecutableInternalRepresentationKHR::sType;
+  public:
+    const 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 ), "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
   {
-    struct PipelineExecutablePropertiesKHR
+    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 ) VULKAN_HPP_NOEXCEPT
+      : stages( stages_ )
+      , name{}
+      , description{}
+      , subgroupSize( subgroupSize_ )
     {
-    protected:
-      PipelineExecutablePropertiesKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(this) = rhs;
-      }
-
-      PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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!" );
-  }
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+    }
 
-  struct PipelineExecutablePropertiesKHR : public layout::PipelineExecutablePropertiesKHR
-  {
-    PipelineExecutablePropertiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::PipelineExecutablePropertiesKHR()
-    {}
+    vk::PipelineExecutablePropertiesKHR & operator=( vk::PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutablePropertiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineExecutablePropertiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineExecutablePropertiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineExecutablePropertiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -55374,8 +50746,13 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineExecutablePropertiesKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineExecutablePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
@@ -55405,49 +50782,35 @@ namespace VULKAN_HPP_NAMESPACE
 #endif  /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
   };
 
-  namespace layout
+  struct PipelineExecutableStatisticKHR
   {
-    struct PipelineExecutableStatisticKHR
+    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() ) VULKAN_HPP_NOEXCEPT
+      : name{}
+      , description{}
+      , format( format_ )
+      , value( value_ )
     {
-    protected:
-      PipelineExecutableStatisticKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineExecutableStatisticKHR*>(this) = rhs;
-      }
-
-      PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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!" );
-  }
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+      vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+    }
 
-  struct PipelineExecutableStatisticKHR : public layout::PipelineExecutableStatisticKHR
-  {
-    PipelineExecutableStatisticKHR() VULKAN_HPP_NOEXCEPT
-      : layout::PipelineExecutableStatisticKHR()
-    {}
+    vk::PipelineExecutableStatisticKHR & operator=( vk::PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableStatisticKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
     PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineExecutableStatisticKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineExecutableStatisticKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineExecutableStatisticKHR const *>(&rhs);
       return *this;
     }
 
@@ -55461,53 +50824,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutableStatisticKHR*>( this );
     }
 
-  private:
-    using layout::PipelineExecutableStatisticKHR::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() ) VULKAN_HPP_NOEXCEPT
-        : pipeline( pipeline_ )
-      {}
-
-      PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineInfoKHR*>(this) = rhs;
-      }
-
-      PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineInfoKHR
   {
     VULKAN_HPP_CONSTEXPR PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineInfoKHR( pipeline_ )
+      : pipeline( pipeline_ )
     {}
 
+    vk::PipelineInfoKHR & operator=( vk::PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -55545,8 +50892,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineInfoKHR;
+    const void* pNext = nullptr;
+    vk::Pipeline pipeline;
   };
   static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -55563,12 +50912,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     PushConstantRange( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPushConstantRange*>(this) = rhs;
+      *this = rhs;
     }
 
     PushConstantRange& operator=( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPushConstantRange*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PushConstantRange const *>(&rhs);
       return *this;
     }
 
@@ -55620,63 +50969,34 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(),
-                                                     uint32_t setLayoutCount_ = 0,
-                                                     const vk::DescriptorSetLayout* pSetLayouts_ = nullptr,
-                                                     uint32_t pushConstantRangeCount_ = 0,
-                                                     const vk::PushConstantRange* pPushConstantRanges_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , setLayoutCount( setLayoutCount_ )
-        , pSetLayouts( pSetLayouts_ )
-        , pushConstantRangeCount( pushConstantRangeCount_ )
-        , pPushConstantRanges( pPushConstantRanges_ )
-      {}
-
-      PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this) = rhs;
-      }
-
-      PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineLayoutCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(),
                                                    uint32_t setLayoutCount_ = 0,
                                                    const vk::DescriptorSetLayout* pSetLayouts_ = nullptr,
                                                    uint32_t pushConstantRangeCount_ = 0,
                                                    const vk::PushConstantRange* pPushConstantRanges_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineLayoutCreateInfo( flags_, setLayoutCount_, pSetLayouts_, pushConstantRangeCount_, pPushConstantRanges_ )
+      : flags( flags_ )
+      , setLayoutCount( setLayoutCount_ )
+      , pSetLayouts( pSetLayouts_ )
+      , pushConstantRangeCount( pushConstantRangeCount_ )
+      , pPushConstantRanges( pPushConstantRanges_ )
     {}
 
+    vk::PipelineLayoutCreateInfo & operator=( vk::PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineLayoutCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineLayoutCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineLayoutCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineLayoutCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -55742,61 +51062,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineLayoutCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(),
-                                                                                vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled,
-                                                                                float extraPrimitiveOverestimationSize_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , conservativeRasterizationMode( conservativeRasterizationMode_ )
-        , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
-      {}
-
-      PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineRasterizationConservativeStateCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(),
                                                                               vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled,
                                                                               float extraPrimitiveOverestimationSize_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationConservativeStateCreateInfoEXT( flags_, conservativeRasterizationMode_, extraPrimitiveOverestimationSize_ )
+      : flags( flags_ )
+      , conservativeRasterizationMode( conservativeRasterizationMode_ )
+      , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
     {}
 
+    vk::PipelineRasterizationConservativeStateCreateInfoEXT & operator=( vk::PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationConservativeStateCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationConservativeStateCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineRasterizationConservativeStateCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineRasterizationConservativeStateCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -55848,57 +51149,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineRasterizationConservativeStateCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags;
+    vk::ConservativeRasterizationModeEXT conservativeRasterizationMode;
+    float extraPrimitiveOverestimationSize;
   };
   static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationConservativeStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineRasterizationDepthClipStateCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(),
-                                                                             vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , depthClipEnable( depthClipEnable_ )
-      {}
-
-      PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineRasterizationDepthClipStateCreateInfoEXT
+  struct PipelineRasterizationDepthClipStateCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(),
                                                                            vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( flags_, depthClipEnable_ )
+      : flags( flags_ )
+      , depthClipEnable( depthClipEnable_ )
     {}
 
+    vk::PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( vk::PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationDepthClipStateCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineRasterizationDepthClipStateCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineRasterizationDepthClipStateCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -55943,65 +51225,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineRasterizationDepthClipStateCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags;
+    vk::Bool32 depthClipEnable;
   };
   static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationDepthClipStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineRasterizationLineStateCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault,
-                                                                        vk::Bool32 stippledLineEnable_ = 0,
-                                                                        uint32_t lineStippleFactor_ = 0,
-                                                                        uint16_t lineStipplePattern_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : lineRasterizationMode( lineRasterizationMode_ )
-        , stippledLineEnable( stippledLineEnable_ )
-        , lineStippleFactor( lineStippleFactor_ )
-        , lineStipplePattern( lineStipplePattern_ )
-      {}
-
-      PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 PipelineRasterizationLineStateCreateInfoEXT : public layout::PipelineRasterizationLineStateCreateInfoEXT
+  struct PipelineRasterizationLineStateCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault,
                                                                       vk::Bool32 stippledLineEnable_ = 0,
                                                                       uint32_t lineStippleFactor_ = 0,
                                                                       uint16_t lineStipplePattern_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationLineStateCreateInfoEXT( lineRasterizationMode_, stippledLineEnable_, lineStippleFactor_, lineStipplePattern_ )
+      : lineRasterizationMode( lineRasterizationMode_ )
+      , stippledLineEnable( stippledLineEnable_ )
+      , lineStippleFactor( lineStippleFactor_ )
+      , lineStipplePattern( lineStipplePattern_ )
     {}
 
+    vk::PipelineRasterizationLineStateCreateInfoEXT & operator=( vk::PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationLineStateCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationLineStateCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineRasterizationLineStateCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineRasterizationLineStateCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -56060,53 +51318,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineRasterizationLineStateCreateInfoEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT
-        : rasterizationOrder( rasterizationOrder_ )
-      {}
-
-      PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this) = rhs;
-      }
-
-      PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineRasterizationStateRasterizationOrderAMD
   {
     VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationStateRasterizationOrderAMD( rasterizationOrder_ )
+      : rasterizationOrder( rasterizationOrder_ )
     {}
 
+    vk::PipelineRasterizationStateRasterizationOrderAMD & operator=( vk::PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateRasterizationOrderAMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationStateRasterizationOrderAMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineRasterizationStateRasterizationOrderAMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineRasterizationStateRasterizationOrderAMD const *>(&rhs);
       return *this;
     }
 
@@ -56144,57 +51386,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineRasterizationStateRasterizationOrderAMD::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
+    const void* pNext = nullptr;
+    vk::RasterizationOrderAMD rasterizationOrder;
   };
   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:
-      VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(),
-                                                                          uint32_t rasterizationStream_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , rasterizationStream( rasterizationStream_ )
-      {}
-
-      PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineRasterizationStateStreamCreateInfoEXT
+  struct PipelineRasterizationStateStreamCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(),
                                                                         uint32_t rasterizationStream_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationStateStreamCreateInfoEXT( flags_, rasterizationStream_ )
+      : flags( flags_ )
+      , rasterizationStream( rasterizationStream_ )
     {}
 
+    vk::PipelineRasterizationStateStreamCreateInfoEXT & operator=( vk::PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateStreamCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRasterizationStateStreamCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineRasterizationStateStreamCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineRasterizationStateStreamCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -56239,53 +51460,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineRasterizationStateStreamCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::PipelineRasterizationStateStreamCreateFlagsEXT flags;
+    uint32_t rasterizationStream;
   };
   static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRasterizationStateStreamCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineRepresentativeFragmentTestStateCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
-      {}
-
-      PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PipelineRepresentativeFragmentTestStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( representativeFragmentTestEnable_ )
+      : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
     {}
 
+    vk::PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=( vk::PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRepresentativeFragmentTestStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineRepresentativeFragmentTestStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -56323,57 +51526,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
+    const void* pNext = nullptr;
+    vk::Bool32 representativeFragmentTestEnable;
   };
   static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineRepresentativeFragmentTestStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineSampleLocationsStateCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0,
-                                                                      vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() ) VULKAN_HPP_NOEXCEPT
-        : sampleLocationsEnable( sampleLocationsEnable_ )
-        , sampleLocationsInfo( sampleLocationsInfo_ )
-      {}
-
-      PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineSampleLocationsStateCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0,
                                                                     vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineSampleLocationsStateCreateInfoEXT( sampleLocationsEnable_, sampleLocationsInfo_ )
+      : sampleLocationsEnable( sampleLocationsEnable_ )
+      , sampleLocationsInfo( sampleLocationsInfo_ )
     {}
 
+    vk::PipelineSampleLocationsStateCreateInfoEXT & operator=( vk::PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineSampleLocationsStateCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineSampleLocationsStateCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineSampleLocationsStateCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineSampleLocationsStateCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -56418,52 +51600,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineSampleLocationsStateCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::Bool32 sampleLocationsEnable;
+    vk::SampleLocationsInfoEXT sampleLocationsInfo;
   };
   static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineSampleLocationsStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
   {
-    struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
-    {
-    protected:
-      PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() VULKAN_HPP_NOEXCEPT
-      : layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT()
+    PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( uint32_t requiredSubgroupSize_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : requiredSubgroupSize( requiredSubgroupSize_ )
     {}
 
+    vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT & operator=( vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -56489,53 +51654,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+    void* pNext = nullptr;
+    uint32_t requiredSubgroupSize;
   };
   static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineTessellationDomainOriginStateCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT
-        : domainOrigin( domainOrigin_ )
-      {}
-
-      PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this) = rhs;
-      }
-
-      PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineTessellationDomainOriginStateCreateInfo
   {
     VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineTessellationDomainOriginStateCreateInfo( domainOrigin_ )
+      : domainOrigin( domainOrigin_ )
     {}
 
+    vk::PipelineTessellationDomainOriginStateCreateInfo & operator=( vk::PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineTessellationDomainOriginStateCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineTessellationDomainOriginStateCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineTessellationDomainOriginStateCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineTessellationDomainOriginStateCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -56573,8 +51719,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineTessellationDomainOriginStateCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
+    const void* pNext = nullptr;
+    vk::TessellationDomainOrigin domainOrigin;
   };
   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!" );
@@ -56589,12 +51737,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this) = rhs;
+      *this = rhs;
     }
 
     VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this) = rhs;
+      *this = *reinterpret_cast<vk::VertexInputBindingDivisorDescriptionEXT const *>(&rhs);
       return *this;
     }
 
@@ -56638,51 +51786,28 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
-                                                                         const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
-        , pVertexBindingDivisors( pVertexBindingDivisors_ )
-      {}
-
-      PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this) = rhs;
-      }
-
-      PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineVertexInputDivisorStateCreateInfoEXT
+  struct PipelineVertexInputDivisorStateCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
                                                                        const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineVertexInputDivisorStateCreateInfoEXT( vertexBindingDivisorCount_, pVertexBindingDivisors_ )
+      : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
+      , pVertexBindingDivisors( pVertexBindingDivisors_ )
     {}
 
+    vk::PipelineVertexInputDivisorStateCreateInfoEXT & operator=( vk::PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineVertexInputDivisorStateCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineVertexInputDivisorStateCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineVertexInputDivisorStateCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineVertexInputDivisorStateCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -56727,61 +51852,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineVertexInputDivisorStateCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
+    const void* pNext = nullptr;
+    uint32_t vertexBindingDivisorCount;
+    const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
   };
   static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineVertexInputDivisorStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault,
-                                                                               uint32_t customSampleOrderCount_ = 0,
-                                                                               const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : sampleOrderType( sampleOrderType_ )
-        , customSampleOrderCount( customSampleOrderCount_ )
-        , pCustomSampleOrders( pCustomSampleOrders_ )
-      {}
-
-      PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault,
                                                                              uint32_t customSampleOrderCount_ = 0,
                                                                              const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( sampleOrderType_, customSampleOrderCount_, pCustomSampleOrders_ )
+      : sampleOrderType( sampleOrderType_ )
+      , customSampleOrderCount( customSampleOrderCount_ )
+      , pCustomSampleOrders( pCustomSampleOrders_ )
     {}
 
+    vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=( vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -56833,57 +51936,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
-                                                                              const vk::Rect2D* pExclusiveScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : exclusiveScissorCount( exclusiveScissorCount_ )
-        , pExclusiveScissors( pExclusiveScissors_ )
-      {}
-
-      PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineViewportExclusiveScissorStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
                                                                             const vk::Rect2D* pExclusiveScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( exclusiveScissorCount_, pExclusiveScissors_ )
+      : exclusiveScissorCount( exclusiveScissorCount_ )
+      , pExclusiveScissors( pExclusiveScissors_ )
     {}
 
+    vk::PipelineViewportExclusiveScissorStateCreateInfoNV & operator=( vk::PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportExclusiveScissorStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineViewportExclusiveScissorStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineViewportExclusiveScissorStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -56928,8 +52012,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineViewportExclusiveScissorStateCreateInfoNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
+    const void* pNext = nullptr;
+    uint32_t exclusiveScissorCount;
+    const vk::Rect2D* pExclusiveScissors;
   };
   static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportExclusiveScissorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
@@ -56944,12 +52031,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkShadingRatePaletteNV*>(this) = rhs;
+      *this = rhs;
     }
 
     ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkShadingRatePaletteNV*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ShadingRatePaletteNV const *>(&rhs);
       return *this;
     }
 
@@ -56993,55 +52080,30 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct PipelineViewportShadingRateImageStateCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0,
-                                                                              uint32_t viewportCount_ = 0,
-                                                                              const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : shadingRateImageEnable( shadingRateImageEnable_ )
-        , viewportCount( viewportCount_ )
-        , pShadingRatePalettes( pShadingRatePalettes_ )
-      {}
-
-      PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PipelineViewportShadingRateImageStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0,
                                                                             uint32_t viewportCount_ = 0,
                                                                             const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportShadingRateImageStateCreateInfoNV( shadingRateImageEnable_, viewportCount_, pShadingRatePalettes_ )
+      : shadingRateImageEnable( shadingRateImageEnable_ )
+      , viewportCount( viewportCount_ )
+      , pShadingRatePalettes( pShadingRatePalettes_ )
     {}
 
+    vk::PipelineViewportShadingRateImageStateCreateInfoNV & operator=( vk::PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportShadingRateImageStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportShadingRateImageStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineViewportShadingRateImageStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineViewportShadingRateImageStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -57093,8 +52155,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineViewportShadingRateImageStateCreateInfoNV::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportShadingRateImageStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
@@ -57113,12 +52179,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkViewportSwizzleNV*>(this) = rhs;
+      *this = rhs;
     }
 
     ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkViewportSwizzleNV*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ViewportSwizzleNV const *>(&rhs);
       return *this;
     }
 
@@ -57178,55 +52244,30 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(),
-                                                                     uint32_t viewportCount_ = 0,
-                                                                     const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , viewportCount( viewportCount_ )
-        , pViewportSwizzles( pViewportSwizzles_ )
-      {}
-
-      PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct PipelineViewportSwizzleStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(),
                                                                    uint32_t viewportCount_ = 0,
                                                                    const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportSwizzleStateCreateInfoNV( flags_, viewportCount_, pViewportSwizzles_ )
+      : flags( flags_ )
+      , viewportCount( viewportCount_ )
+      , pViewportSwizzles( pViewportSwizzles_ )
     {}
 
+    vk::PipelineViewportSwizzleStateCreateInfoNV & operator=( vk::PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportSwizzleStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportSwizzleStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineViewportSwizzleStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineViewportSwizzleStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -57278,8 +52319,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineViewportSwizzleStateCreateInfoNV::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PipelineViewportSwizzleStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
@@ -57294,12 +52339,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     ViewportWScalingNV( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkViewportWScalingNV*>(this) = rhs;
+      *this = rhs;
     }
 
     ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkViewportWScalingNV*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ViewportWScalingNV const *>(&rhs);
       return *this;
     }
 
@@ -57343,55 +52388,30 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0,
-                                                                      uint32_t viewportCount_ = 0,
-                                                                      const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : viewportWScalingEnable( viewportWScalingEnable_ )
-        , viewportCount( viewportCount_ )
-        , pViewportWScalings( pViewportWScalings_ )
-      {}
-
-      PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this) = rhs;
-      }
-
-      PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PipelineViewportWScalingStateCreateInfoNV
+  struct PipelineViewportWScalingStateCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0,
                                                                     uint32_t viewportCount_ = 0,
                                                                     const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportWScalingStateCreateInfoNV( viewportWScalingEnable_, viewportCount_, pViewportWScalings_ )
+      : viewportWScalingEnable( viewportWScalingEnable_ )
+      , viewportCount( viewportCount_ )
+      , pViewportWScalings( pViewportWScalings_ )
     {}
 
+    vk::PipelineViewportWScalingStateCreateInfoNV & operator=( vk::PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportWScalingStateCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PipelineViewportWScalingStateCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PipelineViewportWScalingStateCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::PipelineViewportWScalingStateCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -57443,55 +52463,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PipelineViewportWScalingStateCreateInfoNV::sType;
+  public:
+    const 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 ), "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
 
-  namespace layout
-  {
-    struct PresentFrameTokenGGP
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : frameToken( frameToken_ )
-      {}
-
-      PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPresentFrameTokenGGP*>(this) = rhs;
-      }
-
-      PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PresentFrameTokenGGP
   {
     VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::PresentFrameTokenGGP( frameToken_ )
+      : frameToken( frameToken_ )
     {}
 
+    vk::PresentFrameTokenGGP & operator=( vk::PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentFrameTokenGGP ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PresentFrameTokenGGP( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PresentFrameTokenGGP::operator=(rhs);
+      *this = *reinterpret_cast<vk::PresentFrameTokenGGP const *>(&rhs);
       return *this;
     }
 
@@ -57529,57 +52532,16 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PresentFrameTokenGGP::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePresentFrameTokenGGP;
+    const void* pNext = nullptr;
+    GgpFrameToken frameToken;
   };
   static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentFrameTokenGGP>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_GGP*/
 
-  namespace layout
-  {
-    struct PresentInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : waitSemaphoreCount( waitSemaphoreCount_ )
-        , pWaitSemaphores( pWaitSemaphores_ )
-        , swapchainCount( swapchainCount_ )
-        , pSwapchains( pSwapchains_ )
-        , pImageIndices( pImageIndices_ )
-        , pResults( pResults_ )
-      {}
-
-      PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPresentInfoKHR*>(this) = rhs;
-      }
-
-      PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PresentInfoKHR
   {
     VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
                                          const vk::Semaphore* pWaitSemaphores_ = nullptr,
@@ -57587,16 +52549,28 @@ namespace VULKAN_HPP_NAMESPACE
                                          const vk::SwapchainKHR* pSwapchains_ = nullptr,
                                          const uint32_t* pImageIndices_ = nullptr,
                                          vk::Result* pResults_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PresentInfoKHR( waitSemaphoreCount_, pWaitSemaphores_, swapchainCount_, pSwapchains_, pImageIndices_, pResults_ )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphores( pWaitSemaphores_ )
+      , swapchainCount( swapchainCount_ )
+      , pSwapchains( pSwapchains_ )
+      , pImageIndices( pImageIndices_ )
+      , pResults( pResults_ )
     {}
 
+    vk::PresentInfoKHR & operator=( vk::PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PresentInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PresentInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PresentInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -57669,8 +52643,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PresentInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -57694,12 +52675,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     RectLayerKHR( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkRectLayerKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkRectLayerKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::RectLayerKHR const *>(&rhs);
       return *this;
     }
 
@@ -57761,12 +52742,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     PresentRegionKHR( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPresentRegionKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPresentRegionKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PresentRegionKHR const *>(&rhs);
       return *this;
     }
 
@@ -57810,51 +52791,28 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = 0,
-                                              const vk::PresentRegionKHR* pRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : swapchainCount( swapchainCount_ )
-        , pRegions( pRegions_ )
-      {}
-
-      PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPresentRegionsKHR*>(this) = rhs;
-      }
-
-      PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::PresentRegionsKHR
+  struct PresentRegionsKHR
   {
     VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = 0,
                                             const vk::PresentRegionKHR* pRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PresentRegionsKHR( swapchainCount_, pRegions_ )
+      : swapchainCount( swapchainCount_ )
+      , pRegions( pRegions_ )
     {}
 
+    vk::PresentRegionsKHR & operator=( vk::PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentRegionsKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PresentRegionsKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PresentRegionsKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::PresentRegionsKHR const *>(&rhs);
       return *this;
     }
 
@@ -57899,8 +52857,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PresentRegionsKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePresentRegionsKHR;
+    const void* pNext = nullptr;
+    uint32_t swapchainCount;
+    const vk::PresentRegionKHR* pRegions;
   };
   static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentRegionsKHR>::value, "struct wrapper is not a standard layout!" );
@@ -57915,12 +52876,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPresentTimeGOOGLE*>(this) = rhs;
+      *this = rhs;
     }
 
     PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkPresentTimeGOOGLE*>(this) = rhs;
+      *this = *reinterpret_cast<vk::PresentTimeGOOGLE const *>(&rhs);
       return *this;
     }
 
@@ -57964,51 +52925,28 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
-                                                   const vk::PresentTimeGOOGLE* pTimes_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : swapchainCount( swapchainCount_ )
-        , pTimes( pTimes_ )
-      {}
-
-      PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this) = rhs;
-      }
-
-      PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct PresentTimesInfoGOOGLE
   {
     VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
                                                  const vk::PresentTimeGOOGLE* pTimes_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::PresentTimesInfoGOOGLE( swapchainCount_, pTimes_ )
+      : swapchainCount( swapchainCount_ )
+      , pTimes( pTimes_ )
     {}
 
+    vk::PresentTimesInfoGOOGLE & operator=( vk::PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentTimesInfoGOOGLE ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::PresentTimesInfoGOOGLE( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::PresentTimesInfoGOOGLE::operator=(rhs);
+      *this = *reinterpret_cast<vk::PresentTimesInfoGOOGLE const *>(&rhs);
       return *this;
     }
 
@@ -58053,53 +52991,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::PresentTimesInfoGOOGLE::sType;
+  public:
+    const vk::StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
+    const void* pNext = nullptr;
+    uint32_t swapchainCount;
+    const vk::PresentTimeGOOGLE* pTimes;
   };
   static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<PresentTimesInfoGOOGLE>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ProtectedSubmitInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : protectedSubmit( protectedSubmit_ )
-      {}
-
-      ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkProtectedSubmitInfo*>(this) = rhs;
-      }
-
-      ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ProtectedSubmitInfo
+  struct ProtectedSubmitInfo
   {
     VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::ProtectedSubmitInfo( protectedSubmit_ )
+      : protectedSubmit( protectedSubmit_ )
     {}
 
+    vk::ProtectedSubmitInfo & operator=( vk::ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ProtectedSubmitInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ProtectedSubmitInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ProtectedSubmitInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ProtectedSubmitInfo const *>(&rhs);
       return *this;
     }
 
@@ -58137,65 +53057,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ProtectedSubmitInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eProtectedSubmitInfo;
+    const void* pNext = nullptr;
+    vk::Bool32 protectedSubmit;
   };
   static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ProtectedSubmitInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct QueryPoolCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(),
-                                                vk::QueryType queryType_ = vk::QueryType::eOcclusion,
-                                                uint32_t queryCount_ = 0,
-                                                vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , queryType( queryType_ )
-        , queryCount( queryCount_ )
-        , pipelineStatistics( pipelineStatistics_ )
-      {}
-
-      QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkQueryPoolCreateInfo*>(this) = rhs;
-      }
-
-      QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::QueryPoolCreateInfo
+  struct QueryPoolCreateInfo
   {
     VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(),
                                               vk::QueryType queryType_ = vk::QueryType::eOcclusion,
                                               uint32_t queryCount_ = 0,
                                               vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::QueryPoolCreateInfo( flags_, queryType_, queryCount_, pipelineStatistics_ )
+      : flags( flags_ )
+      , queryType( queryType_ )
+      , queryCount( queryCount_ )
+      , pipelineStatistics( pipelineStatistics_ )
     {}
 
+    vk::QueryPoolCreateInfo & operator=( vk::QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::QueryPoolCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::QueryPoolCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::QueryPoolCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -58254,53 +53149,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::QueryPoolCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT
-        : performanceCountersSampling( performanceCountersSampling_ )
-      {}
-
-      QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkQueryPoolCreateInfoINTEL*>(this) = rhs;
-      }
-
-      QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::QueryPoolCreateInfoINTEL
+  struct QueryPoolCreateInfoINTEL
   {
     VULKAN_HPP_CONSTEXPR QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT
-      : layout::QueryPoolCreateInfoINTEL( performanceCountersSampling_ )
+      : performanceCountersSampling( performanceCountersSampling_ )
     {}
 
+    vk::QueryPoolCreateInfoINTEL & operator=( vk::QueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolCreateInfoINTEL ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::QueryPoolCreateInfoINTEL( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::QueryPoolCreateInfoINTEL::operator=(rhs);
+      *this = *reinterpret_cast<vk::QueryPoolCreateInfoINTEL const *>(&rhs);
       return *this;
     }
 
@@ -58338,52 +53217,119 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::QueryPoolCreateInfoINTEL::sType;
+  public:
+    const vk::StructureType sType = StructureType::eQueryPoolCreateInfoINTEL;
+    const void* pNext = nullptr;
+    vk::QueryPoolSamplingModeINTEL performanceCountersSampling;
   };
   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 QueryPoolPerformanceCreateInfoKHR
   {
-    struct QueueFamilyCheckpointPropertiesNV
+    VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_ = 0,
+                                                            uint32_t counterIndexCount_ = 0,
+                                                            const uint32_t* pCounterIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : queueFamilyIndex( queueFamilyIndex_ )
+      , counterIndexCount( counterIndexCount_ )
+      , pCounterIndices( pCounterIndices_ )
+    {}
+
+    vk::QueryPoolPerformanceCreateInfoKHR & operator=( vk::QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    protected:
-      QueueFamilyCheckpointPropertiesNV() VULKAN_HPP_NOEXCEPT
-      {}
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolPerformanceCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
 
-      QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this) = rhs;
-      }
+    QueryPoolPerformanceCreateInfoKHR( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
 
-      QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this) = rhs;
-        return *this;
-      }
+    QueryPoolPerformanceCreateInfoKHR& operator=( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<vk::QueryPoolPerformanceCreateInfoKHR const *>(&rhs);
+      return *this;
+    }
 
-    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!" );
-  }
+    QueryPoolPerformanceCreateInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    QueryPoolPerformanceCreateInfoKHR & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) VULKAN_HPP_NOEXCEPT
+    {
+      queueFamilyIndex = queueFamilyIndex_;
+      return *this;
+    }
+
+    QueryPoolPerformanceCreateInfoKHR & setCounterIndexCount( uint32_t counterIndexCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      counterIndexCount = counterIndexCount_;
+      return *this;
+    }
+
+    QueryPoolPerformanceCreateInfoKHR & setPCounterIndices( const uint32_t* pCounterIndices_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pCounterIndices = pCounterIndices_;
+      return *this;
+    }
+
+    operator VkQueryPoolPerformanceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>( this );
+    }
+
+    operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>( this );
+    }
 
-  struct QueueFamilyCheckpointPropertiesNV : public layout::QueueFamilyCheckpointPropertiesNV
+    bool operator==( QueryPoolPerformanceCreateInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( queueFamilyIndex == rhs.queueFamilyIndex )
+          && ( counterIndexCount == rhs.counterIndexCount )
+          && ( pCounterIndices == rhs.pCounterIndices );
+    }
+
+    bool operator!=( QueryPoolPerformanceCreateInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    const vk::StructureType sType = StructureType::eQueryPoolPerformanceCreateInfoKHR;
+    const void* pNext = nullptr;
+    uint32_t queueFamilyIndex;
+    uint32_t counterIndexCount;
+    const uint32_t* pCounterIndices;
+  };
+  static_assert( sizeof( QueryPoolPerformanceCreateInfoKHR ) == sizeof( VkQueryPoolPerformanceCreateInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<QueryPoolPerformanceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+  struct QueueFamilyCheckpointPropertiesNV
   {
-    QueueFamilyCheckpointPropertiesNV() VULKAN_HPP_NOEXCEPT
-      : layout::QueueFamilyCheckpointPropertiesNV()
+    QueueFamilyCheckpointPropertiesNV( vk::PipelineStageFlags checkpointExecutionStageMask_ = vk::PipelineStageFlags() ) VULKAN_HPP_NOEXCEPT
+      : checkpointExecutionStageMask( checkpointExecutionStageMask_ )
     {}
 
+    vk::QueueFamilyCheckpointPropertiesNV & operator=( vk::QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::QueueFamilyCheckpointPropertiesNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::QueueFamilyCheckpointPropertiesNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::QueueFamilyCheckpointPropertiesNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::QueueFamilyCheckpointPropertiesNV const *>(&rhs);
       return *this;
     }
 
@@ -58409,25 +53355,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::QueueFamilyCheckpointPropertiesNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
+    void* pNext = nullptr;
+    vk::PipelineStageFlags checkpointExecutionStageMask;
   };
   static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<QueueFamilyCheckpointPropertiesNV>::value, "struct wrapper is not a standard layout!" );
 
   struct QueueFamilyProperties
   {
-    QueueFamilyProperties() VULKAN_HPP_NOEXCEPT
+    QueueFamilyProperties( vk::QueueFlags queueFlags_ = vk::QueueFlags(),
+                           uint32_t queueCount_ = 0,
+                           uint32_t timestampValidBits_ = 0,
+                           vk::Extent3D minImageTransferGranularity_ = vk::Extent3D() ) VULKAN_HPP_NOEXCEPT
+      : queueFlags( queueFlags_ )
+      , queueCount( queueCount_ )
+      , timestampValidBits( timestampValidBits_ )
+      , minImageTransferGranularity( minImageTransferGranularity_ )
     {}
 
     QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkQueueFamilyProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     QueueFamilyProperties& operator=( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkQueueFamilyProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::QueueFamilyProperties const *>(&rhs);
       return *this;
     }
 
@@ -58463,46 +53418,26 @@ namespace VULKAN_HPP_NAMESPACE
   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
   {
-    struct QueueFamilyProperties2
-    {
-    protected:
-      QueueFamilyProperties2() VULKAN_HPP_NOEXCEPT
-      {}
-
-      QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkQueueFamilyProperties2*>(this) = rhs;
-      }
-
-      QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    QueueFamilyProperties2() VULKAN_HPP_NOEXCEPT
-      : layout::QueueFamilyProperties2()
+    QueueFamilyProperties2( vk::QueueFamilyProperties queueFamilyProperties_ = vk::QueueFamilyProperties() ) VULKAN_HPP_NOEXCEPT
+      : queueFamilyProperties( queueFamilyProperties_ )
     {}
 
+    vk::QueueFamilyProperties2 & operator=( vk::QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::QueueFamilyProperties2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::QueueFamilyProperties2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::QueueFamilyProperties2::operator=(rhs);
+      *this = *reinterpret_cast<vk::QueueFamilyProperties2 const *>(&rhs);
       return *this;
     }
 
@@ -58528,69 +53463,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::QueueFamilyProperties2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eQueueFamilyProperties2;
+    void* pNext = nullptr;
+    vk::QueueFamilyProperties queueFamilyProperties;
   };
   static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<QueueFamilyProperties2>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct RayTracingShaderGroupCreateInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral,
-                                                              uint32_t generalShader_ = 0,
-                                                              uint32_t closestHitShader_ = 0,
-                                                              uint32_t anyHitShader_ = 0,
-                                                              uint32_t intersectionShader_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : type( type_ )
-        , generalShader( generalShader_ )
-        , closestHitShader( closestHitShader_ )
-        , anyHitShader( anyHitShader_ )
-        , intersectionShader( intersectionShader_ )
-      {}
-
-      RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this) = rhs;
-      }
-
-      RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct RayTracingShaderGroupCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral,
                                                             uint32_t generalShader_ = 0,
                                                             uint32_t closestHitShader_ = 0,
                                                             uint32_t anyHitShader_ = 0,
                                                             uint32_t intersectionShader_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::RayTracingShaderGroupCreateInfoNV( type_, generalShader_, closestHitShader_, anyHitShader_, intersectionShader_ )
+      : type( type_ )
+      , generalShader( generalShader_ )
+      , closestHitShader( closestHitShader_ )
+      , anyHitShader( anyHitShader_ )
+      , intersectionShader( intersectionShader_ )
     {}
 
+    vk::RayTracingShaderGroupCreateInfoNV & operator=( vk::RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RayTracingShaderGroupCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RayTracingShaderGroupCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RayTracingShaderGroupCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::RayTracingShaderGroupCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -58656,65 +53564,19 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RayTracingShaderGroupCreateInfoNV::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , stageCount( stageCount_ )
-        , pStages( pStages_ )
-        , groupCount( groupCount_ )
-        , pGroups( pGroups_ )
-        , maxRecursionDepth( maxRecursionDepth_ )
-        , layout( layout_ )
-        , basePipelineHandle( basePipelineHandle_ )
-        , basePipelineIndex( basePipelineIndex_ )
-      {}
-
-      RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this) = rhs;
-      }
-
-      RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::RayTracingPipelineCreateInfoNV
+  struct RayTracingPipelineCreateInfoNV
   {
     VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
                                                          uint32_t stageCount_ = 0,
@@ -58725,16 +53587,31 @@ namespace VULKAN_HPP_NAMESPACE
                                                          vk::PipelineLayout layout_ = vk::PipelineLayout(),
                                                          vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
                                                          int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::RayTracingPipelineCreateInfoNV( flags_, stageCount_, pStages_, groupCount_, pGroups_, maxRecursionDepth_, layout_, basePipelineHandle_, basePipelineIndex_ )
+      : flags( flags_ )
+      , stageCount( stageCount_ )
+      , pStages( pStages_ )
+      , groupCount( groupCount_ )
+      , pGroups( pGroups_ )
+      , maxRecursionDepth( maxRecursionDepth_ )
+      , layout( layout_ )
+      , basePipelineHandle( basePipelineHandle_ )
+      , basePipelineIndex( basePipelineIndex_ )
     {}
 
+    vk::RayTracingPipelineCreateInfoNV & operator=( vk::RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RayTracingPipelineCreateInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RayTracingPipelineCreateInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RayTracingPipelineCreateInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::RayTracingPipelineCreateInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -58828,25 +53705,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RayTracingPipelineCreateInfoNV::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RayTracingPipelineCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
 
   struct RefreshCycleDurationGOOGLE
   {
-    RefreshCycleDurationGOOGLE() VULKAN_HPP_NOEXCEPT
+    RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : refreshDuration( refreshDuration_ )
     {}
 
     RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this) = rhs;
+      *this = rhs;
     }
 
     RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this) = rhs;
+      *this = *reinterpret_cast<vk::RefreshCycleDurationGOOGLE const *>(&rhs);
       return *this;
     }
 
@@ -58876,51 +53764,28 @@ namespace VULKAN_HPP_NAMESPACE
   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:
-      VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0,
-                                                             const vk::ImageView* pAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : attachmentCount( attachmentCount_ )
-        , pAttachments( pAttachments_ )
-      {}
-
-      RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
-      }
-
-      RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct RenderPassAttachmentBeginInfoKHR
   {
     VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0,
                                                            const vk::ImageView* pAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassAttachmentBeginInfoKHR( attachmentCount_, pAttachments_ )
+      : attachmentCount( attachmentCount_ )
+      , pAttachments( pAttachments_ )
     {}
 
+    vk::RenderPassAttachmentBeginInfoKHR & operator=( vk::RenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassAttachmentBeginInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassAttachmentBeginInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RenderPassAttachmentBeginInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::RenderPassAttachmentBeginInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -58965,69 +53830,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RenderPassAttachmentBeginInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR;
+    const void* pNext = nullptr;
+    uint32_t attachmentCount;
+    const vk::ImageView* pAttachments;
   };
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : renderPass( renderPass_ )
-        , framebuffer( framebuffer_ )
-        , renderArea( renderArea_ )
-        , clearValueCount( clearValueCount_ )
-        , pClearValues( pClearValues_ )
-      {}
-
-      RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassBeginInfo*>(this) = rhs;
-      }
-
-      RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct RenderPassBeginInfo
   {
     VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassBeginInfo( renderPass_, framebuffer_, renderArea_, clearValueCount_, pClearValues_ )
+      : renderPass( renderPass_ )
+      , framebuffer( framebuffer_ )
+      , renderArea( renderArea_ )
+      , clearValueCount( clearValueCount_ )
+      , pClearValues( pClearValues_ )
     {}
 
+    vk::RenderPassBeginInfo & operator=( vk::RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassBeginInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassBeginInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RenderPassBeginInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::RenderPassBeginInfo const *>(&rhs);
       return *this;
     }
 
@@ -59093,8 +53932,14 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RenderPassBeginInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" );
@@ -59125,12 +53970,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSubpassDescription*>(this) = rhs;
+      *this = rhs;
     }
 
     SubpassDescription& operator=( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSubpassDescription*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SubpassDescription const *>(&rhs);
       return *this;
     }
 
@@ -59258,12 +54103,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSubpassDependency*>(this) = rhs;
+      *this = rhs;
     }
 
     SubpassDependency& operator=( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSubpassDependency*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SubpassDependency const *>(&rhs);
       return *this;
     }
 
@@ -59347,53 +54192,7 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct RenderPassCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , attachmentCount( attachmentCount_ )
-        , pAttachments( pAttachments_ )
-        , subpassCount( subpassCount_ )
-        , pSubpasses( pSubpasses_ )
-        , dependencyCount( dependencyCount_ )
-        , pDependencies( pDependencies_ )
-      {}
-
-      RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassCreateInfo*>(this) = rhs;
-      }
-
-      RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct RenderPassCreateInfo
   {
     VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
                                                uint32_t attachmentCount_ = 0,
@@ -59402,16 +54201,29 @@ namespace VULKAN_HPP_NAMESPACE
                                                const vk::SubpassDescription* pSubpasses_ = nullptr,
                                                uint32_t dependencyCount_ = 0,
                                                const vk::SubpassDependency* pDependencies_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassCreateInfo( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_ )
+      : flags( flags_ )
+      , attachmentCount( attachmentCount_ )
+      , pAttachments( pAttachments_ )
+      , subpassCount( subpassCount_ )
+      , pSubpasses( pSubpasses_ )
+      , dependencyCount( dependencyCount_ )
+      , pDependencies( pDependencies_ )
     {}
 
+    vk::RenderPassCreateInfo & operator=( vk::RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RenderPassCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::RenderPassCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -59491,71 +54303,21 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RenderPassCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : 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 ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSubpassDescription2KHR*>(this) = rhs;
-      }
-
-      SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::SubpassDescription2KHR
+  struct SubpassDescription2KHR
   {
     VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(),
                                                  vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
@@ -59568,16 +54330,33 @@ namespace VULKAN_HPP_NAMESPACE
                                                  const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
                                                  uint32_t preserveAttachmentCount_ = 0,
                                                  const uint32_t* pPreserveAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassDescription2KHR( flags_, pipelineBindPoint_, viewMask_, inputAttachmentCount_, pInputAttachments_, colorAttachmentCount_, pColorAttachments_, pResolveAttachments_, pDepthStencilAttachment_, preserveAttachmentCount_, pPreserveAttachments_ )
+      : flags( flags_ )
+      , pipelineBindPoint( pipelineBindPoint_ )
+      , viewMask( viewMask_ )
+      , inputAttachmentCount( inputAttachmentCount_ )
+      , pInputAttachments( pInputAttachments_ )
+      , colorAttachmentCount( colorAttachmentCount_ )
+      , pColorAttachments( pColorAttachments_ )
+      , pResolveAttachments( pResolveAttachments_ )
+      , pDepthStencilAttachment( pDepthStencilAttachment_ )
+      , preserveAttachmentCount( preserveAttachmentCount_ )
+      , pPreserveAttachments( pPreserveAttachments_ )
     {}
 
+    vk::SubpassDescription2KHR & operator=( vk::SubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDescription2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassDescription2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SubpassDescription2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SubpassDescription2KHR const *>(&rhs);
       return *this;
     }
 
@@ -59685,62 +54464,25 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SubpassDescription2KHR::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : srcSubpass( srcSubpass_ )
-        , dstSubpass( dstSubpass_ )
-        , srcStageMask( srcStageMask_ )
-        , dstStageMask( dstStageMask_ )
-        , srcAccessMask( srcAccessMask_ )
-        , dstAccessMask( dstAccessMask_ )
-        , dependencyFlags( dependencyFlags_ )
-        , viewOffset( viewOffset_ )
-      {}
-
-      SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSubpassDependency2KHR*>(this) = rhs;
-      }
-
-      SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SubpassDependency2KHR
   {
     VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
                                                 uint32_t dstSubpass_ = 0,
@@ -59750,16 +54492,30 @@ namespace VULKAN_HPP_NAMESPACE
                                                 vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
                                                 vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(),
                                                 int32_t viewOffset_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassDependency2KHR( srcSubpass_, dstSubpass_, srcStageMask_, dstStageMask_, srcAccessMask_, dstAccessMask_, dependencyFlags_, viewOffset_ )
+      : srcSubpass( srcSubpass_ )
+      , dstSubpass( dstSubpass_ )
+      , srcStageMask( srcStageMask_ )
+      , dstStageMask( dstStageMask_ )
+      , srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
+      , dependencyFlags( dependencyFlags_ )
+      , viewOffset( viewOffset_ )
     {}
 
+    vk::SubpassDependency2KHR & operator=( vk::SubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDependency2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassDependency2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SubpassDependency2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SubpassDependency2KHR const *>(&rhs);
       return *this;
     }
 
@@ -59846,65 +54602,22 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SubpassDependency2KHR::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , attachmentCount( attachmentCount_ )
-        , pAttachments( pAttachments_ )
-        , subpassCount( subpassCount_ )
-        , pSubpasses( pSubpasses_ )
-        , dependencyCount( dependencyCount_ )
-        , pDependencies( pDependencies_ )
-        , correlatedViewMaskCount( correlatedViewMaskCount_ )
-        , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
-      {}
-
-      RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this) = rhs;
-      }
-
-      RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct RenderPassCreateInfo2KHR
   {
     VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
                                                    uint32_t attachmentCount_ = 0,
@@ -59915,16 +54628,31 @@ namespace VULKAN_HPP_NAMESPACE
                                                    const vk::SubpassDependency2KHR* pDependencies_ = nullptr,
                                                    uint32_t correlatedViewMaskCount_ = 0,
                                                    const uint32_t* pCorrelatedViewMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassCreateInfo2KHR( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_, correlatedViewMaskCount_, pCorrelatedViewMasks_ )
+      : flags( flags_ )
+      , attachmentCount( attachmentCount_ )
+      , pAttachments( pAttachments_ )
+      , subpassCount( subpassCount_ )
+      , pSubpasses( pSubpasses_ )
+      , dependencyCount( dependencyCount_ )
+      , pDependencies( pDependencies_ )
+      , correlatedViewMaskCount( correlatedViewMaskCount_ )
+      , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
     {}
 
+    vk::RenderPassCreateInfo2KHR & operator=( vk::RenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassCreateInfo2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassCreateInfo2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RenderPassCreateInfo2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::RenderPassCreateInfo2KHR const *>(&rhs);
       return *this;
     }
 
@@ -60018,53 +54746,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RenderPassCreateInfo2KHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassCreateInfo2KHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct RenderPassFragmentDensityMapCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() ) VULKAN_HPP_NOEXCEPT
-        : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
-      {}
-
-      RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this) = rhs;
-      }
-
-      RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct RenderPassFragmentDensityMapCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassFragmentDensityMapCreateInfoEXT( fragmentDensityMapAttachment_ )
+      : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
     {}
 
+    vk::RenderPassFragmentDensityMapCreateInfoEXT & operator=( vk::RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassFragmentDensityMapCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassFragmentDensityMapCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RenderPassFragmentDensityMapCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::RenderPassFragmentDensityMapCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -60102,57 +54819,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RenderPassFragmentDensityMapCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::AttachmentReference fragmentDensityMapAttachment;
   };
   static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassFragmentDensityMapCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct RenderPassInputAttachmentAspectCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
-                                                                      const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : aspectReferenceCount( aspectReferenceCount_ )
-        , pAspectReferences( pAspectReferences_ )
-      {}
-
-      RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this) = rhs;
-      }
-
-      RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct RenderPassInputAttachmentAspectCreateInfo
   {
     VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
                                                                     const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassInputAttachmentAspectCreateInfo( aspectReferenceCount_, pAspectReferences_ )
+      : aspectReferenceCount( aspectReferenceCount_ )
+      , pAspectReferences( pAspectReferences_ )
     {}
 
+    vk::RenderPassInputAttachmentAspectCreateInfo & operator=( vk::RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassInputAttachmentAspectCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassInputAttachmentAspectCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RenderPassInputAttachmentAspectCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::RenderPassInputAttachmentAspectCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -60197,56 +54893,16 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RenderPassInputAttachmentAspectCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
+    const void* pNext = nullptr;
+    uint32_t aspectReferenceCount;
+    const vk::InputAttachmentAspectReference* pAspectReferences;
   };
   static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassInputAttachmentAspectCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct RenderPassMultiviewCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : subpassCount( subpassCount_ )
-        , pViewMasks( pViewMasks_ )
-        , dependencyCount( dependencyCount_ )
-        , pViewOffsets( pViewOffsets_ )
-        , correlationMaskCount( correlationMaskCount_ )
-        , pCorrelationMasks( pCorrelationMasks_ )
-      {}
-
-      RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this) = rhs;
-      }
-
-      RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct RenderPassMultiviewCreateInfo
   {
     VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0,
                                                         const uint32_t* pViewMasks_ = nullptr,
@@ -60254,16 +54910,28 @@ namespace VULKAN_HPP_NAMESPACE
                                                         const int32_t* pViewOffsets_ = nullptr,
                                                         uint32_t correlationMaskCount_ = 0,
                                                         const uint32_t* pCorrelationMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassMultiviewCreateInfo( subpassCount_, pViewMasks_, dependencyCount_, pViewOffsets_, correlationMaskCount_, pCorrelationMasks_ )
+      : subpassCount( subpassCount_ )
+      , pViewMasks( pViewMasks_ )
+      , dependencyCount( dependencyCount_ )
+      , pViewOffsets( pViewOffsets_ )
+      , correlationMaskCount( correlationMaskCount_ )
+      , pCorrelationMasks( pCorrelationMasks_ )
     {}
 
+    vk::RenderPassMultiviewCreateInfo & operator=( vk::RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassMultiviewCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassMultiviewCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RenderPassMultiviewCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::RenderPassMultiviewCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -60336,8 +55004,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RenderPassMultiviewCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<RenderPassMultiviewCreateInfo>::value, "struct wrapper is not a standard layout!" );
@@ -60352,12 +55027,12 @@ namespace VULKAN_HPP_NAMESPACE
 
     SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this) = rhs;
+      *this = rhs;
     }
 
     SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SubpassSampleLocationsEXT const *>(&rhs);
       return *this;
     }
 
@@ -60401,59 +55076,32 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct RenderPassSampleLocationsBeginInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
-                                                                  const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
-                                                                  uint32_t postSubpassSampleLocationsCount_ = 0,
-                                                                  const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
-        , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
-        , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
-        , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
-      {}
-
-      RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this) = rhs;
-      }
-
-      RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct RenderPassSampleLocationsBeginInfoEXT
   {
     VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
                                                                 const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
                                                                 uint32_t postSubpassSampleLocationsCount_ = 0,
                                                                 const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassSampleLocationsBeginInfoEXT( attachmentInitialSampleLocationsCount_, pAttachmentInitialSampleLocations_, postSubpassSampleLocationsCount_, pPostSubpassSampleLocations_ )
+      : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
+      , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
+      , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
+      , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
     {}
 
+    vk::RenderPassSampleLocationsBeginInfoEXT & operator=( vk::RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassSampleLocationsBeginInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::RenderPassSampleLocationsBeginInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::RenderPassSampleLocationsBeginInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::RenderPassSampleLocationsBeginInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -60512,86 +55160,18 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::RenderPassSampleLocationsBeginInfoEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : 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 ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSamplerCreateInfo*>(this) = rhs;
-      }
-
-      SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::SamplerCreateInfo
+  struct SamplerCreateInfo
   {
     VULKAN_HPP_CONSTEXPR SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(),
                                             vk::Filter magFilter_ = vk::Filter::eNearest,
@@ -60609,16 +55189,38 @@ namespace VULKAN_HPP_NAMESPACE
                                             float maxLod_ = 0,
                                             vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack,
                                             vk::Bool32 unnormalizedCoordinates_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerCreateInfo( flags_, magFilter_, minFilter_, mipmapMode_, addressModeU_, addressModeV_, addressModeW_, mipLodBias_, anisotropyEnable_, maxAnisotropy_, compareEnable_, compareOp_, minLod_, maxLod_, borderColor_, unnormalizedCoordinates_ )
+      : 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::SamplerCreateInfo & operator=( vk::SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SamplerCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::SamplerCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -60761,53 +55363,49 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SamplerCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SamplerReductionModeCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage ) VULKAN_HPP_NOEXCEPT
-        : reductionMode( reductionMode_ )
-      {}
-
-      SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this) = rhs;
-      }
-
-      SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SamplerReductionModeCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerReductionModeCreateInfoEXT( reductionMode_ )
+      : reductionMode( reductionMode_ )
     {}
 
+    vk::SamplerReductionModeCreateInfoEXT & operator=( vk::SamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerReductionModeCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerReductionModeCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SamplerReductionModeCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::SamplerReductionModeCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -60845,62 +55443,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SamplerReductionModeCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::SamplerReductionModeEXT reductionMode;
   };
   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:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : format( format_ )
-        , ycbcrModel( ycbcrModel_ )
-        , ycbcrRange( ycbcrRange_ )
-        , components( components_ )
-        , xChromaOffset( xChromaOffset_ )
-        , yChromaOffset( yChromaOffset_ )
-        , chromaFilter( chromaFilter_ )
-        , forceExplicitReconstruction( forceExplicitReconstruction_ )
-      {}
-
-      SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this) = rhs;
-      }
-
-      SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SamplerYcbcrConversionCreateInfo
   {
     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined,
                                                            vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity,
@@ -60910,16 +55461,30 @@ namespace VULKAN_HPP_NAMESPACE
                                                            vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven,
                                                            vk::Filter chromaFilter_ = vk::Filter::eNearest,
                                                            vk::Bool32 forceExplicitReconstruction_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerYcbcrConversionCreateInfo( format_, ycbcrModel_, ycbcrRange_, components_, xChromaOffset_, yChromaOffset_, chromaFilter_, forceExplicitReconstruction_ )
+      : format( format_ )
+      , ycbcrModel( ycbcrModel_ )
+      , ycbcrRange( ycbcrRange_ )
+      , components( components_ )
+      , xChromaOffset( xChromaOffset_ )
+      , yChromaOffset( yChromaOffset_ )
+      , chromaFilter( chromaFilter_ )
+      , forceExplicitReconstruction( forceExplicitReconstruction_ )
     {}
 
+    vk::SamplerYcbcrConversionCreateInfo & operator=( vk::SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerYcbcrConversionCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SamplerYcbcrConversionCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::SamplerYcbcrConversionCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -61006,52 +55571,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SamplerYcbcrConversionCreateInfo::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerYcbcrConversionCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SamplerYcbcrConversionImageFormatProperties
-    {
-    protected:
-      SamplerYcbcrConversionImageFormatProperties() VULKAN_HPP_NOEXCEPT
-      {}
-
-      SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this) = rhs;
-      }
-
-      SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SamplerYcbcrConversionImageFormatProperties
   {
-    SamplerYcbcrConversionImageFormatProperties() VULKAN_HPP_NOEXCEPT
-      : layout::SamplerYcbcrConversionImageFormatProperties()
+    SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ )
     {}
 
+    vk::SamplerYcbcrConversionImageFormatProperties & operator=( vk::SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionImageFormatProperties ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerYcbcrConversionImageFormatProperties( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SamplerYcbcrConversionImageFormatProperties::operator=(rhs);
+      *this = *reinterpret_cast<vk::SamplerYcbcrConversionImageFormatProperties const *>(&rhs);
       return *this;
     }
 
@@ -61077,53 +55631,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SamplerYcbcrConversionImageFormatProperties::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
+    void* pNext = nullptr;
+    uint32_t combinedImageSamplerDescriptorCount;
   };
   static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerYcbcrConversionImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SamplerYcbcrConversionInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() ) VULKAN_HPP_NOEXCEPT
-        : conversion( conversion_ )
-      {}
-
-      SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this) = rhs;
-      }
-
-      SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SamplerYcbcrConversionInfo
   {
     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerYcbcrConversionInfo( conversion_ )
+      : conversion( conversion_ )
     {}
 
+    vk::SamplerYcbcrConversionInfo & operator=( vk::SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SamplerYcbcrConversionInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SamplerYcbcrConversionInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::SamplerYcbcrConversionInfo const *>(&rhs);
       return *this;
     }
 
@@ -61161,53 +55696,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SamplerYcbcrConversionInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSamplerYcbcrConversionInfo;
+    const void* pNext = nullptr;
+    vk::SamplerYcbcrConversion conversion;
   };
   static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SamplerYcbcrConversionInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SemaphoreCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-      {}
-
-      SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreCreateInfo*>(this) = rhs;
-      }
-
-      SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::SemaphoreCreateInfo
+  struct SemaphoreCreateInfo
   {
     VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreCreateInfo( flags_ )
+      : flags( flags_ )
     {}
 
+    vk::SemaphoreCreateInfo & operator=( vk::SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SemaphoreCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::SemaphoreCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -61245,57 +55761,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SemaphoreCreateInfo::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSemaphoreCreateInfo;
+    const void* pNext = nullptr;
+    vk::SemaphoreCreateFlags flags;
   };
   static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreCreateInfo>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SemaphoreGetFdInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
-                                                  vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : semaphore( semaphore_ )
-        , handleType( handleType_ )
-      {}
-
-      SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this) = rhs;
-      }
-
-      SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SemaphoreGetFdInfoKHR
   {
     VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
                                                 vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreGetFdInfoKHR( semaphore_, handleType_ )
+      : semaphore( semaphore_ )
+      , handleType( handleType_ )
     {}
 
+    vk::SemaphoreGetFdInfoKHR & operator=( vk::SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreGetFdInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreGetFdInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SemaphoreGetFdInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SemaphoreGetFdInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -61340,59 +55835,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SemaphoreGetFdInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
+    const void* pNext = nullptr;
+    vk::Semaphore semaphore;
+    vk::ExternalSemaphoreHandleTypeFlagBits handleType;
   };
   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
 
-  namespace layout
-  {
-    struct SemaphoreGetWin32HandleInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
-                                                           vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-        : semaphore( semaphore_ )
-        , handleType( handleType_ )
-      {}
-
-      SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this) = rhs;
-      }
-
-      SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SemaphoreGetWin32HandleInfoKHR
   {
     VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
                                                          vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreGetWin32HandleInfoKHR( semaphore_, handleType_ )
+      : semaphore( semaphore_ )
+      , handleType( handleType_ )
     {}
 
+    vk::SemaphoreGetWin32HandleInfoKHR & operator=( vk::SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreGetWin32HandleInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SemaphoreGetWin32HandleInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SemaphoreGetWin32HandleInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -61437,58 +55912,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SemaphoreGetWin32HandleInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
+    const void* pNext = nullptr;
+    vk::Semaphore semaphore;
+    vk::ExternalSemaphoreHandleTypeFlagBits handleType;
   };
   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*/
 
-  namespace layout
-  {
-    struct SemaphoreSignalInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SemaphoreSignalInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
-                                                   uint64_t value_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : semaphore( semaphore_ )
-        , value( value_ )
-      {}
-
-      SemaphoreSignalInfoKHR( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreSignalInfoKHR*>(this) = rhs;
-      }
-
-      SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreSignalInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::eSemaphoreSignalInfoKHR;
-      const void* pNext = nullptr;
-      vk::Semaphore semaphore;
-      uint64_t value;
-    };
-    static_assert( sizeof( SemaphoreSignalInfoKHR ) == sizeof( VkSemaphoreSignalInfoKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct SemaphoreSignalInfoKHR : public layout::SemaphoreSignalInfoKHR
+  struct SemaphoreSignalInfoKHR
   {
     VULKAN_HPP_CONSTEXPR SemaphoreSignalInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
                                                  uint64_t value_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreSignalInfoKHR( semaphore_, value_ )
+      : semaphore( semaphore_ )
+      , value( value_ )
     {}
 
+    vk::SemaphoreSignalInfoKHR & operator=( vk::SemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreSignalInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SemaphoreSignalInfoKHR( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreSignalInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SemaphoreSignalInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SemaphoreSignalInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -61533,57 +55988,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SemaphoreSignalInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSemaphoreSignalInfoKHR;
+    const void* pNext = nullptr;
+    vk::Semaphore semaphore;
+    uint64_t value;
   };
   static_assert( sizeof( SemaphoreSignalInfoKHR ) == sizeof( VkSemaphoreSignalInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreSignalInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SemaphoreTypeCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfoKHR( vk::SemaphoreTypeKHR semaphoreType_ = vk::SemaphoreTypeKHR::eBinary,
-                                                       uint64_t initialValue_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : semaphoreType( semaphoreType_ )
-        , initialValue( initialValue_ )
-      {}
-
-      SemaphoreTypeCreateInfoKHR( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreTypeCreateInfoKHR*>(this) = rhs;
-      }
-
-      SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreTypeCreateInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::eSemaphoreTypeCreateInfoKHR;
-      const void* pNext = nullptr;
-      vk::SemaphoreTypeKHR semaphoreType;
-      uint64_t initialValue;
-    };
-    static_assert( sizeof( SemaphoreTypeCreateInfoKHR ) == sizeof( VkSemaphoreTypeCreateInfoKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct SemaphoreTypeCreateInfoKHR : public layout::SemaphoreTypeCreateInfoKHR
+  struct SemaphoreTypeCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfoKHR( vk::SemaphoreTypeKHR semaphoreType_ = vk::SemaphoreTypeKHR::eBinary,
                                                      uint64_t initialValue_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreTypeCreateInfoKHR( semaphoreType_, initialValue_ )
+      : semaphoreType( semaphoreType_ )
+      , initialValue( initialValue_ )
     {}
 
+    vk::SemaphoreTypeCreateInfoKHR & operator=( vk::SemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreTypeCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SemaphoreTypeCreateInfoKHR( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreTypeCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SemaphoreTypeCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SemaphoreTypeCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -61628,65 +56063,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SemaphoreTypeCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSemaphoreTypeCreateInfoKHR;
+    const void* pNext = nullptr;
+    vk::SemaphoreTypeKHR semaphoreType;
+    uint64_t initialValue;
   };
   static_assert( sizeof( SemaphoreTypeCreateInfoKHR ) == sizeof( VkSemaphoreTypeCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreTypeCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SemaphoreWaitInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SemaphoreWaitInfoKHR( vk::SemaphoreWaitFlagsKHR flags_ = vk::SemaphoreWaitFlagsKHR(),
-                                                 uint32_t semaphoreCount_ = 0,
-                                                 const vk::Semaphore* pSemaphores_ = nullptr,
-                                                 const uint64_t* pValues_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , semaphoreCount( semaphoreCount_ )
-        , pSemaphores( pSemaphores_ )
-        , pValues( pValues_ )
-      {}
-
-      SemaphoreWaitInfoKHR( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreWaitInfoKHR*>(this) = rhs;
-      }
-
-      SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSemaphoreWaitInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::eSemaphoreWaitInfoKHR;
-      const void* pNext = nullptr;
-      vk::SemaphoreWaitFlagsKHR flags;
-      uint32_t semaphoreCount;
-      const vk::Semaphore* pSemaphores;
-      const uint64_t* pValues;
-    };
-    static_assert( sizeof( SemaphoreWaitInfoKHR ) == sizeof( VkSemaphoreWaitInfoKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct SemaphoreWaitInfoKHR : public layout::SemaphoreWaitInfoKHR
+  struct SemaphoreWaitInfoKHR
   {
     VULKAN_HPP_CONSTEXPR SemaphoreWaitInfoKHR( vk::SemaphoreWaitFlagsKHR flags_ = vk::SemaphoreWaitFlagsKHR(),
                                                uint32_t semaphoreCount_ = 0,
                                                const vk::Semaphore* pSemaphores_ = nullptr,
                                                const uint64_t* pValues_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreWaitInfoKHR( flags_, semaphoreCount_, pSemaphores_, pValues_ )
+      : flags( flags_ )
+      , semaphoreCount( semaphoreCount_ )
+      , pSemaphores( pSemaphores_ )
+      , pValues( pValues_ )
     {}
 
+    vk::SemaphoreWaitInfoKHR & operator=( vk::SemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreWaitInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SemaphoreWaitInfoKHR( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SemaphoreWaitInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SemaphoreWaitInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SemaphoreWaitInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -61745,61 +56156,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SemaphoreWaitInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSemaphoreWaitInfoKHR;
+    const void* pNext = nullptr;
+    vk::SemaphoreWaitFlagsKHR flags;
+    uint32_t semaphoreCount;
+    const vk::Semaphore* pSemaphores;
+    const uint64_t* pValues;
   };
   static_assert( sizeof( SemaphoreWaitInfoKHR ) == sizeof( VkSemaphoreWaitInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SemaphoreWaitInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ShaderModuleCreateInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(),
-                                                   size_t codeSize_ = 0,
-                                                   const uint32_t* pCode_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , codeSize( codeSize_ )
-        , pCode( pCode_ )
-      {}
-
-      ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkShaderModuleCreateInfo*>(this) = rhs;
-      }
-
-      ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ShaderModuleCreateInfo
   {
     VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(),
                                                  size_t codeSize_ = 0,
                                                  const uint32_t* pCode_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ShaderModuleCreateInfo( flags_, codeSize_, pCode_ )
+      : flags( flags_ )
+      , codeSize( codeSize_ )
+      , pCode( pCode_ )
     {}
 
+    vk::ShaderModuleCreateInfo & operator=( vk::ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ShaderModuleCreateInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ShaderModuleCreateInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ShaderModuleCreateInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::ShaderModuleCreateInfo const *>(&rhs);
       return *this;
     }
 
@@ -61851,53 +56242,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ShaderModuleCreateInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() ) VULKAN_HPP_NOEXCEPT
-        : validationCache( validationCache_ )
-      {}
-
-      ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this) = rhs;
-      }
-
-      ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ShaderModuleValidationCacheCreateInfoEXT
+  struct ShaderModuleValidationCacheCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() ) VULKAN_HPP_NOEXCEPT
-      : layout::ShaderModuleValidationCacheCreateInfoEXT( validationCache_ )
+      : validationCache( validationCache_ )
     {}
 
+    vk::ShaderModuleValidationCacheCreateInfoEXT & operator=( vk::ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ShaderModuleValidationCacheCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ShaderModuleValidationCacheCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ShaderModuleValidationCacheCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ShaderModuleValidationCacheCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -61935,25 +56309,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ShaderModuleValidationCacheCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::ValidationCacheEXT validationCache;
   };
   static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ShaderModuleValidationCacheCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
   struct ShaderResourceUsageAMD
   {
-    ShaderResourceUsageAMD() VULKAN_HPP_NOEXCEPT
+    ShaderResourceUsageAMD( uint32_t numUsedVgprs_ = 0,
+                            uint32_t numUsedSgprs_ = 0,
+                            uint32_t ldsSizePerLocalWorkGroup_ = 0,
+                            size_t ldsUsageSizeInBytes_ = 0,
+                            size_t scratchMemUsageInBytes_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : numUsedVgprs( numUsedVgprs_ )
+      , numUsedSgprs( numUsedSgprs_ )
+      , ldsSizePerLocalWorkGroup( ldsSizePerLocalWorkGroup_ )
+      , ldsUsageSizeInBytes( ldsUsageSizeInBytes_ )
+      , scratchMemUsageInBytes( scratchMemUsageInBytes_ )
     {}
 
     ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkShaderResourceUsageAMD*>(this) = rhs;
+      *this = rhs;
     }
 
     ShaderResourceUsageAMD& operator=( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkShaderResourceUsageAMD*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ShaderResourceUsageAMD const *>(&rhs);
       return *this;
     }
 
@@ -61993,17 +56378,32 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ShaderStatisticsInfoAMD
   {
-    ShaderStatisticsInfoAMD() VULKAN_HPP_NOEXCEPT
-    {}
+    ShaderStatisticsInfoAMD( vk::ShaderStageFlags shaderStageMask_ = vk::ShaderStageFlags(),
+                             vk::ShaderResourceUsageAMD resourceUsage_ = vk::ShaderResourceUsageAMD(),
+                             uint32_t numPhysicalVgprs_ = 0,
+                             uint32_t numPhysicalSgprs_ = 0,
+                             uint32_t numAvailableVgprs_ = 0,
+                             uint32_t numAvailableSgprs_ = 0,
+                             std::array<uint32_t,3> const& computeWorkGroupSize_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+      : shaderStageMask( shaderStageMask_ )
+      , resourceUsage( resourceUsage_ )
+      , numPhysicalVgprs( numPhysicalVgprs_ )
+      , numPhysicalSgprs( numPhysicalSgprs_ )
+      , numAvailableVgprs( numAvailableVgprs_ )
+      , numAvailableSgprs( numAvailableSgprs_ )
+      , computeWorkGroupSize{}
+    {
+      vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( computeWorkGroupSize, computeWorkGroupSize_ );
+    }
 
     ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this) = rhs;
+      *this = rhs;
     }
 
     ShaderStatisticsInfoAMD& operator=( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this) = rhs;
+      *this = *reinterpret_cast<vk::ShaderStatisticsInfoAMD const *>(&rhs);
       return *this;
     }
 
@@ -62045,46 +56445,26 @@ namespace VULKAN_HPP_NAMESPACE
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this) = rhs;
-      }
-
-      SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::SharedPresentSurfaceCapabilitiesKHR
+  struct SharedPresentSurfaceCapabilitiesKHR
   {
-    SharedPresentSurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT
-      : layout::SharedPresentSurfaceCapabilitiesKHR()
+    SharedPresentSurfaceCapabilitiesKHR( vk::ImageUsageFlags sharedPresentSupportedUsageFlags_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT
+      : sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ )
     {}
 
+    vk::SharedPresentSurfaceCapabilitiesKHR & operator=( vk::SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SharedPresentSurfaceCapabilitiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SharedPresentSurfaceCapabilitiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SharedPresentSurfaceCapabilitiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SharedPresentSurfaceCapabilitiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -62110,25 +56490,32 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SharedPresentSurfaceCapabilitiesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
+    void* pNext = nullptr;
+    vk::ImageUsageFlags sharedPresentSupportedUsageFlags;
   };
   static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SharedPresentSurfaceCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseImageFormatProperties
   {
-    SparseImageFormatProperties() VULKAN_HPP_NOEXCEPT
+    SparseImageFormatProperties( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
+                                 vk::Extent3D imageGranularity_ = vk::Extent3D(),
+                                 vk::SparseImageFormatFlags flags_ = vk::SparseImageFormatFlags() ) VULKAN_HPP_NOEXCEPT
+      : aspectMask( aspectMask_ )
+      , imageGranularity( imageGranularity_ )
+      , flags( flags_ )
     {}
 
     SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageFormatProperties*>(this) = rhs;
+      *this = rhs;
     }
 
     SparseImageFormatProperties& operator=( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageFormatProperties*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SparseImageFormatProperties const *>(&rhs);
       return *this;
     }
 
@@ -62162,46 +56549,26 @@ namespace VULKAN_HPP_NAMESPACE
   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
   {
-    struct SparseImageFormatProperties2
-    {
-    protected:
-      SparseImageFormatProperties2() VULKAN_HPP_NOEXCEPT
-      {}
-
-      SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSparseImageFormatProperties2*>(this) = rhs;
-      }
-
-      SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
-  {
-    SparseImageFormatProperties2() VULKAN_HPP_NOEXCEPT
-      : layout::SparseImageFormatProperties2()
+    SparseImageFormatProperties2( vk::SparseImageFormatProperties properties_ = vk::SparseImageFormatProperties() ) VULKAN_HPP_NOEXCEPT
+      : properties( properties_ )
     {}
 
+    vk::SparseImageFormatProperties2 & operator=( vk::SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SparseImageFormatProperties2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SparseImageFormatProperties2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SparseImageFormatProperties2::operator=(rhs);
+      *this = *reinterpret_cast<vk::SparseImageFormatProperties2 const *>(&rhs);
       return *this;
     }
 
@@ -62227,25 +56594,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SparseImageFormatProperties2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSparseImageFormatProperties2;
+    void* pNext = nullptr;
+    vk::SparseImageFormatProperties properties;
   };
   static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageFormatProperties2>::value, "struct wrapper is not a standard layout!" );
 
   struct SparseImageMemoryRequirements
   {
-    SparseImageMemoryRequirements() VULKAN_HPP_NOEXCEPT
+    SparseImageMemoryRequirements( vk::SparseImageFormatProperties formatProperties_ = vk::SparseImageFormatProperties(),
+                                   uint32_t imageMipTailFirstLod_ = 0,
+                                   vk::DeviceSize imageMipTailSize_ = 0,
+                                   vk::DeviceSize imageMipTailOffset_ = 0,
+                                   vk::DeviceSize imageMipTailStride_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : formatProperties( formatProperties_ )
+      , imageMipTailFirstLod( imageMipTailFirstLod_ )
+      , imageMipTailSize( imageMipTailSize_ )
+      , imageMipTailOffset( imageMipTailOffset_ )
+      , imageMipTailStride( imageMipTailStride_ )
     {}
 
     SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageMemoryRequirements*>(this) = rhs;
+      *this = rhs;
     }
 
     SparseImageMemoryRequirements& operator=( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSparseImageMemoryRequirements*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SparseImageMemoryRequirements const *>(&rhs);
       return *this;
     }
 
@@ -62283,46 +56661,26 @@ namespace VULKAN_HPP_NAMESPACE
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this) = rhs;
-      }
-
-      SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SparseImageMemoryRequirements2
   {
-    SparseImageMemoryRequirements2() VULKAN_HPP_NOEXCEPT
-      : layout::SparseImageMemoryRequirements2()
+    SparseImageMemoryRequirements2( vk::SparseImageMemoryRequirements memoryRequirements_ = vk::SparseImageMemoryRequirements() ) VULKAN_HPP_NOEXCEPT
+      : memoryRequirements( memoryRequirements_ )
     {}
 
+    vk::SparseImageMemoryRequirements2 & operator=( vk::SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SparseImageMemoryRequirements2 ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SparseImageMemoryRequirements2( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SparseImageMemoryRequirements2::operator=(rhs);
+      *this = *reinterpret_cast<vk::SparseImageMemoryRequirements2 const *>(&rhs);
       return *this;
     }
 
@@ -62348,59 +56706,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SparseImageMemoryRequirements2::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSparseImageMemoryRequirements2;
+    void* pNext = nullptr;
+    vk::SparseImageMemoryRequirements memoryRequirements;
   };
   static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SparseImageMemoryRequirements2>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_GGP
 
-  namespace layout
-  {
-    struct StreamDescriptorSurfaceCreateInfoGGP
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(),
-                                                                 GgpStreamDescriptor streamDescriptor_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , streamDescriptor( streamDescriptor_ )
-      {}
-
-      StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(this) = rhs;
-      }
-
-      StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct StreamDescriptorSurfaceCreateInfoGGP
   {
     VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(),
                                                                GgpStreamDescriptor streamDescriptor_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::StreamDescriptorSurfaceCreateInfoGGP( flags_, streamDescriptor_ )
+      : flags( flags_ )
+      , streamDescriptor( streamDescriptor_ )
     {}
 
+    vk::StreamDescriptorSurfaceCreateInfoGGP & operator=( vk::StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::StreamDescriptorSurfaceCreateInfoGGP ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::StreamDescriptorSurfaceCreateInfoGGP( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::StreamDescriptorSurfaceCreateInfoGGP::operator=(rhs);
+      *this = *reinterpret_cast<vk::StreamDescriptorSurfaceCreateInfoGGP const *>(&rhs);
       return *this;
     }
 
@@ -62445,60 +56782,17 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::StreamDescriptorSurfaceCreateInfoGGP::sType;
+  public:
+    const vk::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP;
+    const void* pNext = nullptr;
+    vk::StreamDescriptorSurfaceCreateFlagsGGP flags;
+    GgpStreamDescriptor streamDescriptor;
   };
   static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<StreamDescriptorSurfaceCreateInfoGGP>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_GGP*/
 
-  namespace layout
-  {
-    struct SubmitInfo
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : waitSemaphoreCount( waitSemaphoreCount_ )
-        , pWaitSemaphores( pWaitSemaphores_ )
-        , pWaitDstStageMask( pWaitDstStageMask_ )
-        , commandBufferCount( commandBufferCount_ )
-        , pCommandBuffers( pCommandBuffers_ )
-        , signalSemaphoreCount( signalSemaphoreCount_ )
-        , pSignalSemaphores( pSignalSemaphores_ )
-      {}
-
-      SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSubmitInfo*>(this) = rhs;
-      }
-
-      SubmitInfo& operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SubmitInfo
   {
     VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = 0,
                                      const vk::Semaphore* pWaitSemaphores_ = nullptr,
@@ -62507,16 +56801,29 @@ namespace VULKAN_HPP_NAMESPACE
                                      const vk::CommandBuffer* pCommandBuffers_ = nullptr,
                                      uint32_t signalSemaphoreCount_ = 0,
                                      const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::SubmitInfo( waitSemaphoreCount_, pWaitSemaphores_, pWaitDstStageMask_, commandBufferCount_, pCommandBuffers_, signalSemaphoreCount_, pSignalSemaphores_ )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphores( pWaitSemaphores_ )
+      , pWaitDstStageMask( pWaitDstStageMask_ )
+      , commandBufferCount( commandBufferCount_ )
+      , pCommandBuffers( pCommandBuffers_ )
+      , signalSemaphoreCount( signalSemaphoreCount_ )
+      , pSignalSemaphores( pSignalSemaphores_ )
     {}
 
+    vk::SubmitInfo & operator=( vk::SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SubmitInfo ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SubmitInfo( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SubmitInfo& operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SubmitInfo::operator=(rhs);
+      *this = *reinterpret_cast<vk::SubmitInfo const *>(&rhs);
       return *this;
     }
 
@@ -62596,53 +56903,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SubmitInfo::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT
-        : contents( contents_ )
-      {}
-
-      SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSubpassBeginInfoKHR*>(this) = rhs;
-      }
-
-      SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::SubpassBeginInfoKHR
+  struct SubpassBeginInfoKHR
   {
     VULKAN_HPP_CONSTEXPR SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassBeginInfoKHR( contents_ )
+      : contents( contents_ )
     {}
 
+    vk::SubpassBeginInfoKHR & operator=( vk::SubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassBeginInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassBeginInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SubpassBeginInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SubpassBeginInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -62680,61 +56974,38 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SubpassBeginInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSubpassBeginInfoKHR;
+    const void* pNext = nullptr;
+    vk::SubpassContents contents;
   };
   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:
-      VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
-                                                                     vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
-                                                                     const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : depthResolveMode( depthResolveMode_ )
-        , stencilResolveMode( stencilResolveMode_ )
-        , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
-      {}
-
-      SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR*>(this) = rhs;
-      }
-
-      SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SubpassDescriptionDepthStencilResolveKHR
   {
     VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
                                                                    vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
                                                                    const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassDescriptionDepthStencilResolveKHR( depthResolveMode_, stencilResolveMode_, pDepthStencilResolveAttachment_ )
+      : depthResolveMode( depthResolveMode_ )
+      , stencilResolveMode( stencilResolveMode_ )
+      , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
     {}
 
+    vk::SubpassDescriptionDepthStencilResolveKHR & operator=( vk::SubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDescriptionDepthStencilResolveKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassDescriptionDepthStencilResolveKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SubpassDescriptionDepthStencilResolveKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SubpassDescriptionDepthStencilResolveKHR const *>(&rhs);
       return *this;
     }
 
@@ -62786,51 +57057,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SubpassDescriptionDepthStencilResolveKHR::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR SubpassEndInfoKHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSubpassEndInfoKHR*>(this) = rhs;
-      }
-
-      SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SubpassEndInfoKHR
   {
     VULKAN_HPP_CONSTEXPR SubpassEndInfoKHR() VULKAN_HPP_NOEXCEPT
-      : layout::SubpassEndInfoKHR()
     {}
 
+    vk::SubpassEndInfoKHR & operator=( vk::SubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassEndInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SubpassEndInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SubpassEndInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SubpassEndInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -62861,62 +57116,53 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SubpassEndInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSubpassEndInfoKHR;
+    const void* pNext = nullptr;
   };
   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
   {
-    struct SurfaceCapabilities2EXT
-    {
-    protected:
-      SurfaceCapabilities2EXT() VULKAN_HPP_NOEXCEPT
-      {}
-
-      SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this) = rhs;
-      }
-
-      SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::SurfaceCapabilities2EXT
-  {
-    SurfaceCapabilities2EXT() VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceCapabilities2EXT()
+    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() ) VULKAN_HPP_NOEXCEPT
+      : minImageCount( minImageCount_ )
+      , maxImageCount( maxImageCount_ )
+      , currentExtent( currentExtent_ )
+      , minImageExtent( minImageExtent_ )
+      , maxImageExtent( maxImageExtent_ )
+      , maxImageArrayLayers( maxImageArrayLayers_ )
+      , supportedTransforms( supportedTransforms_ )
+      , currentTransform( currentTransform_ )
+      , supportedCompositeAlpha( supportedCompositeAlpha_ )
+      , supportedUsageFlags( supportedUsageFlags_ )
+      , supportedSurfaceCounters( supportedSurfaceCounters_ )
     {}
 
+    vk::SurfaceCapabilities2EXT & operator=( vk::SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilities2EXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceCapabilities2EXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SurfaceCapabilities2EXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::SurfaceCapabilities2EXT const *>(&rhs);
       return *this;
     }
 
@@ -62952,25 +57198,56 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SurfaceCapabilities2EXT::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceCapabilities2EXT>::value, "struct wrapper is not a standard layout!" );
 
   struct SurfaceCapabilitiesKHR
   {
-    SurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT
+    SurfaceCapabilitiesKHR( 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() ) VULKAN_HPP_NOEXCEPT
+      : minImageCount( minImageCount_ )
+      , maxImageCount( maxImageCount_ )
+      , currentExtent( currentExtent_ )
+      , minImageExtent( minImageExtent_ )
+      , maxImageExtent( maxImageExtent_ )
+      , maxImageArrayLayers( maxImageArrayLayers_ )
+      , supportedTransforms( supportedTransforms_ )
+      , currentTransform( currentTransform_ )
+      , supportedCompositeAlpha( supportedCompositeAlpha_ )
+      , supportedUsageFlags( supportedUsageFlags_ )
     {}
 
     SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     SurfaceCapabilitiesKHR& operator=( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SurfaceCapabilitiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -63018,46 +57295,26 @@ namespace VULKAN_HPP_NAMESPACE
   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() VULKAN_HPP_NOEXCEPT
-      {}
-
-      SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this) = rhs;
-      }
-
-      SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct SurfaceCapabilities2KHR
   {
-    SurfaceCapabilities2KHR() VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceCapabilities2KHR()
+    SurfaceCapabilities2KHR( vk::SurfaceCapabilitiesKHR surfaceCapabilities_ = vk::SurfaceCapabilitiesKHR() ) VULKAN_HPP_NOEXCEPT
+      : surfaceCapabilities( surfaceCapabilities_ )
     {}
 
+    vk::SurfaceCapabilities2KHR & operator=( vk::SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilities2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceCapabilities2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SurfaceCapabilities2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SurfaceCapabilities2KHR const *>(&rhs);
       return *this;
     }
 
@@ -63083,55 +57340,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SurfaceCapabilities2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSurfaceCapabilities2KHR;
+    void* pNext = nullptr;
+    vk::SurfaceCapabilitiesKHR surfaceCapabilities;
   };
   static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceCapabilities2KHR>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct SurfaceCapabilitiesFullScreenExclusiveEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
-      {}
-
-      SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this) = rhs;
-      }
-
-      SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SurfaceCapabilitiesFullScreenExclusiveEXT
   {
     VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( fullScreenExclusiveSupported_ )
+      : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
     {}
 
+    vk::SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( vk::SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilitiesFullScreenExclusiveEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SurfaceCapabilitiesFullScreenExclusiveEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::SurfaceCapabilitiesFullScreenExclusiveEXT const *>(&rhs);
       return *this;
     }
 
@@ -63169,8 +57407,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SurfaceCapabilitiesFullScreenExclusiveEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT;
+    void* pNext = nullptr;
+    vk::Bool32 fullScreenExclusiveSupported;
   };
   static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceCapabilitiesFullScreenExclusiveEXT>::value, "struct wrapper is not a standard layout!" );
@@ -63178,17 +57418,20 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SurfaceFormatKHR
   {
-    SurfaceFormatKHR() VULKAN_HPP_NOEXCEPT
+    SurfaceFormatKHR( vk::Format format_ = vk::Format::eUndefined,
+                      vk::ColorSpaceKHR colorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear ) VULKAN_HPP_NOEXCEPT
+      : format( format_ )
+      , colorSpace( colorSpace_ )
     {}
 
     SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSurfaceFormatKHR*>(this) = rhs;
+      *this = rhs;
     }
 
     SurfaceFormatKHR& operator=( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *reinterpret_cast<VkSurfaceFormatKHR*>(this) = rhs;
+      *this = *reinterpret_cast<vk::SurfaceFormatKHR const *>(&rhs);
       return *this;
     }
 
@@ -63220,46 +57463,26 @@ namespace VULKAN_HPP_NAMESPACE
   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!" );
 
-  namespace layout
-  {
-    struct SurfaceFormat2KHR
-    {
-    protected:
-      SurfaceFormat2KHR() VULKAN_HPP_NOEXCEPT
-      {}
-
-      SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSurfaceFormat2KHR*>(this) = rhs;
-      }
-
-      SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SurfaceFormat2KHR
   {
-    SurfaceFormat2KHR() VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceFormat2KHR()
+    SurfaceFormat2KHR( vk::SurfaceFormatKHR surfaceFormat_ = vk::SurfaceFormatKHR() ) VULKAN_HPP_NOEXCEPT
+      : surfaceFormat( surfaceFormat_ )
     {}
 
+    vk::SurfaceFormat2KHR & operator=( vk::SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFormat2KHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceFormat2KHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SurfaceFormat2KHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SurfaceFormat2KHR const *>(&rhs);
       return *this;
     }
 
@@ -63285,55 +57508,36 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SurfaceFormat2KHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSurfaceFormat2KHR;
+    void* pNext = nullptr;
+    vk::SurfaceFormatKHR surfaceFormat;
   };
   static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceFormat2KHR>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct SurfaceFullScreenExclusiveInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT
-        : fullScreenExclusive( fullScreenExclusive_ )
-      {}
-
-      SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(this) = rhs;
-      }
-
-      SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SurfaceFullScreenExclusiveInfoEXT
   {
     VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceFullScreenExclusiveInfoEXT( fullScreenExclusive_ )
+      : fullScreenExclusive( fullScreenExclusive_ )
     {}
 
+    vk::SurfaceFullScreenExclusiveInfoEXT & operator=( vk::SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFullScreenExclusiveInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceFullScreenExclusiveInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SurfaceFullScreenExclusiveInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::SurfaceFullScreenExclusiveInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -63371,8 +57575,10 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SurfaceFullScreenExclusiveInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT;
+    void* pNext = nullptr;
+    vk::FullScreenExclusiveEXT fullScreenExclusive;
   };
   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!" );
@@ -63380,47 +57586,26 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct SurfaceFullScreenExclusiveWin32InfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : hmonitor( hmonitor_ )
-      {}
-
-      SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(this) = rhs;
-      }
-
-      SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SurfaceFullScreenExclusiveWin32InfoEXT
   {
     VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceFullScreenExclusiveWin32InfoEXT( hmonitor_ )
+      : hmonitor( hmonitor_ )
     {}
 
+    vk::SurfaceFullScreenExclusiveWin32InfoEXT & operator=( vk::SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFullScreenExclusiveWin32InfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceFullScreenExclusiveWin32InfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SurfaceFullScreenExclusiveWin32InfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::SurfaceFullScreenExclusiveWin32InfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -63458,54 +57643,35 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SurfaceFullScreenExclusiveWin32InfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT;
+    const void* pNext = nullptr;
+    HMONITOR hmonitor;
   };
   static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceFullScreenExclusiveWin32InfoEXT>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  namespace layout
-  {
-    struct SurfaceProtectedCapabilitiesKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : supportsProtected( supportsProtected_ )
-      {}
-
-      SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(this) = rhs;
-      }
-
-      SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SurfaceProtectedCapabilitiesKHR
   {
     VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceProtectedCapabilitiesKHR( supportsProtected_ )
+      : supportsProtected( supportsProtected_ )
     {}
 
+    vk::SurfaceProtectedCapabilitiesKHR & operator=( vk::SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceProtectedCapabilitiesKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SurfaceProtectedCapabilitiesKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SurfaceProtectedCapabilitiesKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SurfaceProtectedCapabilitiesKHR const *>(&rhs);
       return *this;
     }
 
@@ -63543,53 +57709,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SurfaceProtectedCapabilitiesKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR;
+    const void* pNext = nullptr;
+    vk::Bool32 supportsProtected;
   };
   static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SurfaceProtectedCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SwapchainCounterCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() ) VULKAN_HPP_NOEXCEPT
-        : surfaceCounters( surfaceCounters_ )
-      {}
-
-      SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this) = rhs;
-      }
-
-      SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SwapchainCounterCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() ) VULKAN_HPP_NOEXCEPT
-      : layout::SwapchainCounterCreateInfoEXT( surfaceCounters_ )
+      : surfaceCounters( surfaceCounters_ )
     {}
 
+    vk::SwapchainCounterCreateInfoEXT & operator=( vk::SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainCounterCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SwapchainCounterCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SwapchainCounterCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::SwapchainCounterCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -63627,86 +57774,15 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SwapchainCounterCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::SurfaceCounterFlagsEXT surfaceCounters;
   };
   static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SwapchainCounterCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SwapchainCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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() ) VULKAN_HPP_NOEXCEPT
-        : 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_ )
-      {}
-
-      SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this) = rhs;
-      }
-
-      SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SwapchainCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(),
                                                  vk::SurfaceKHR surface_ = vk::SurfaceKHR(),
@@ -63724,16 +57800,38 @@ namespace VULKAN_HPP_NAMESPACE
                                                  vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate,
                                                  vk::Bool32 clipped_ = 0,
                                                  vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT
-      : layout::SwapchainCreateInfoKHR( flags_, surface_, minImageCount_, imageFormat_, imageColorSpace_, imageExtent_, imageArrayLayers_, imageUsage_, imageSharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, preTransform_, compositeAlpha_, presentMode_, clipped_, oldSwapchain_ )
+      : 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::SwapchainCreateInfoKHR & operator=( vk::SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SwapchainCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SwapchainCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::SwapchainCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -63876,53 +57974,49 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SwapchainCreateInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct SwapchainDisplayNativeHdrCreateInfoAMD
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : localDimmingEnable( localDimmingEnable_ )
-      {}
-
-      SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(this) = rhs;
-      }
-
-      SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct SwapchainDisplayNativeHdrCreateInfoAMD
   {
     VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::SwapchainDisplayNativeHdrCreateInfoAMD( localDimmingEnable_ )
+      : localDimmingEnable( localDimmingEnable_ )
     {}
 
+    vk::SwapchainDisplayNativeHdrCreateInfoAMD & operator=( vk::SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainDisplayNativeHdrCreateInfoAMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::SwapchainDisplayNativeHdrCreateInfoAMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::SwapchainDisplayNativeHdrCreateInfoAMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::SwapchainDisplayNativeHdrCreateInfoAMD const *>(&rhs);
       return *this;
     }
 
@@ -63960,52 +58054,34 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::SwapchainDisplayNativeHdrCreateInfoAMD::sType;
+  public:
+    const vk::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD;
+    const void* pNext = nullptr;
+    vk::Bool32 localDimmingEnable;
   };
   static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<SwapchainDisplayNativeHdrCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
+  struct TextureLODGatherFormatPropertiesAMD
   {
-    struct TextureLODGatherFormatPropertiesAMD
-    {
-    protected:
-      TextureLODGatherFormatPropertiesAMD() VULKAN_HPP_NOEXCEPT
-      {}
-
-      TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this) = rhs;
-      }
-
-      TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::TextureLODGatherFormatPropertiesAMD
-  {
-    TextureLODGatherFormatPropertiesAMD() VULKAN_HPP_NOEXCEPT
-      : layout::TextureLODGatherFormatPropertiesAMD()
+    TextureLODGatherFormatPropertiesAMD( vk::Bool32 supportsTextureGatherLODBiasAMD_ = 0 ) VULKAN_HPP_NOEXCEPT
+      : supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ )
     {}
 
+    vk::TextureLODGatherFormatPropertiesAMD & operator=( vk::TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::TextureLODGatherFormatPropertiesAMD ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::TextureLODGatherFormatPropertiesAMD( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::TextureLODGatherFormatPropertiesAMD::operator=(rhs);
+      *this = *reinterpret_cast<vk::TextureLODGatherFormatPropertiesAMD const *>(&rhs);
       return *this;
     }
 
@@ -64031,65 +58107,40 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::TextureLODGatherFormatPropertiesAMD::sType;
+  public:
+    const vk::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
+    void* pNext = nullptr;
+    vk::Bool32 supportsTextureGatherLODBiasAMD;
   };
   static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<TextureLODGatherFormatPropertiesAMD>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct TimelineSemaphoreSubmitInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfoKHR( uint32_t waitSemaphoreValueCount_ = 0,
-                                                           const uint64_t* pWaitSemaphoreValues_ = nullptr,
-                                                           uint32_t signalSemaphoreValueCount_ = 0,
-                                                           const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : waitSemaphoreValueCount( waitSemaphoreValueCount_ )
-        , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
-        , signalSemaphoreValueCount( signalSemaphoreValueCount_ )
-        , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
-      {}
-
-      TimelineSemaphoreSubmitInfoKHR( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkTimelineSemaphoreSubmitInfoKHR*>(this) = rhs;
-      }
-
-      TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkTimelineSemaphoreSubmitInfoKHR*>(this) = rhs;
-        return *this;
-      }
-
-    public:
-      vk::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfoKHR;
-      const void* pNext = nullptr;
-      uint32_t waitSemaphoreValueCount;
-      const uint64_t* pWaitSemaphoreValues;
-      uint32_t signalSemaphoreValueCount;
-      const uint64_t* pSignalSemaphoreValues;
-    };
-    static_assert( sizeof( TimelineSemaphoreSubmitInfoKHR ) == sizeof( VkTimelineSemaphoreSubmitInfoKHR ), "layout struct and wrapper have different size!" );
-  }
-
-  struct TimelineSemaphoreSubmitInfoKHR : public layout::TimelineSemaphoreSubmitInfoKHR
+  struct TimelineSemaphoreSubmitInfoKHR
   {
     VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfoKHR( uint32_t waitSemaphoreValueCount_ = 0,
                                                          const uint64_t* pWaitSemaphoreValues_ = nullptr,
                                                          uint32_t signalSemaphoreValueCount_ = 0,
                                                          const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::TimelineSemaphoreSubmitInfoKHR( waitSemaphoreValueCount_, pWaitSemaphoreValues_, signalSemaphoreValueCount_, pSignalSemaphoreValues_ )
+      : waitSemaphoreValueCount( waitSemaphoreValueCount_ )
+      , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
+      , signalSemaphoreValueCount( signalSemaphoreValueCount_ )
+      , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
     {}
 
+    vk::TimelineSemaphoreSubmitInfoKHR & operator=( vk::TimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::TimelineSemaphoreSubmitInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     TimelineSemaphoreSubmitInfoKHR( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::TimelineSemaphoreSubmitInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::TimelineSemaphoreSubmitInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::TimelineSemaphoreSubmitInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -64148,61 +58199,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::TimelineSemaphoreSubmitInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfoKHR;
+    const void* pNext = nullptr;
+    uint32_t waitSemaphoreValueCount;
+    const uint64_t* pWaitSemaphoreValues;
+    uint32_t signalSemaphoreValueCount;
+    const uint64_t* pSignalSemaphoreValues;
   };
   static_assert( sizeof( TimelineSemaphoreSubmitInfoKHR ) == sizeof( VkTimelineSemaphoreSubmitInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<TimelineSemaphoreSubmitInfoKHR>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ValidationCacheCreateInfoEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(),
-                                                         size_t initialDataSize_ = 0,
-                                                         const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , initialDataSize( initialDataSize_ )
-        , pInitialData( pInitialData_ )
-      {}
-
-      ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this) = rhs;
-      }
-
-      ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::ValidationCacheCreateInfoEXT
+  struct ValidationCacheCreateInfoEXT
   {
     VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(),
                                                        size_t initialDataSize_ = 0,
                                                        const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ValidationCacheCreateInfoEXT( flags_, initialDataSize_, pInitialData_ )
+      : flags( flags_ )
+      , initialDataSize( initialDataSize_ )
+      , pInitialData( pInitialData_ )
     {}
 
+    vk::ValidationCacheCreateInfoEXT & operator=( vk::ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationCacheCreateInfoEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ValidationCacheCreateInfoEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ValidationCacheCreateInfoEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ValidationCacheCreateInfoEXT const *>(&rhs);
       return *this;
     }
 
@@ -64254,65 +58285,42 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ValidationCacheCreateInfoEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
+    const void* pNext = nullptr;
+    vk::ValidationCacheCreateFlagsEXT flags;
+    size_t initialDataSize;
+    const void* pInitialData;
   };
   static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ValidationCacheCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
 
-  namespace layout
-  {
-    struct ValidationFeaturesEXT
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0,
-                                                  const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
-                                                  uint32_t disabledValidationFeatureCount_ = 0,
-                                                  const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : enabledValidationFeatureCount( enabledValidationFeatureCount_ )
-        , pEnabledValidationFeatures( pEnabledValidationFeatures_ )
-        , disabledValidationFeatureCount( disabledValidationFeatureCount_ )
-        , pDisabledValidationFeatures( pDisabledValidationFeatures_ )
-      {}
-
-      ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkValidationFeaturesEXT*>(this) = rhs;
-      }
-
-      ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ValidationFeaturesEXT
   {
     VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0,
                                                 const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
                                                 uint32_t disabledValidationFeatureCount_ = 0,
                                                 const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ValidationFeaturesEXT( enabledValidationFeatureCount_, pEnabledValidationFeatures_, disabledValidationFeatureCount_, pDisabledValidationFeatures_ )
+      : enabledValidationFeatureCount( enabledValidationFeatureCount_ )
+      , pEnabledValidationFeatures( pEnabledValidationFeatures_ )
+      , disabledValidationFeatureCount( disabledValidationFeatureCount_ )
+      , pDisabledValidationFeatures( pDisabledValidationFeatures_ )
     {}
 
+    vk::ValidationFeaturesEXT & operator=( vk::ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationFeaturesEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ValidationFeaturesEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ValidationFeaturesEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ValidationFeaturesEXT const *>(&rhs);
       return *this;
     }
 
@@ -64371,57 +58379,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ValidationFeaturesEXT::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
-                                               const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : disabledValidationCheckCount( disabledValidationCheckCount_ )
-        , pDisabledValidationChecks( pDisabledValidationChecks_ )
-      {}
-
-      ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkValidationFlagsEXT*>(this) = rhs;
-      }
-
-      ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ValidationFlagsEXT
   {
     VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
                                              const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ValidationFlagsEXT( disabledValidationCheckCount_, pDisabledValidationChecks_ )
+      : disabledValidationCheckCount( disabledValidationCheckCount_ )
+      , pDisabledValidationChecks( pDisabledValidationChecks_ )
     {}
 
+    vk::ValidationFlagsEXT & operator=( vk::ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationFlagsEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ValidationFlagsEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ValidationFlagsEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::ValidationFlagsEXT const *>(&rhs);
       return *this;
     }
 
@@ -64466,59 +58456,39 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ValidationFlagsEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eValidationFlagsEXT;
+    const void* pNext = nullptr;
+    uint32_t disabledValidationCheckCount;
+    const vk::ValidationCheckEXT* pDisabledValidationChecks;
   };
   static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ValidationFlagsEXT>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_VI_NN
 
-  namespace layout
-  {
-    struct ViSurfaceCreateInfoNN
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(),
-                                                  void* window_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , window( window_ )
-      {}
-
-      ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this) = rhs;
-      }
-
-      ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct ViSurfaceCreateInfoNN
   {
     VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(),
                                                 void* window_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::ViSurfaceCreateInfoNN( flags_, window_ )
+      : flags( flags_ )
+      , window( window_ )
     {}
 
+    vk::ViSurfaceCreateInfoNN & operator=( vk::ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::ViSurfaceCreateInfoNN ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::ViSurfaceCreateInfoNN( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::ViSurfaceCreateInfoNN::operator=(rhs);
+      *this = *reinterpret_cast<vk::ViSurfaceCreateInfoNN const *>(&rhs);
       return *this;
     }
 
@@ -64563,8 +58533,11 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::ViSurfaceCreateInfoNN::sType;
+  public:
+    const vk::StructureType sType = StructureType::eViSurfaceCreateInfoNN;
+    const void* pNext = nullptr;
+    vk::ViSurfaceCreateFlagsNN flags;
+    void* window;
   };
   static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<ViSurfaceCreateInfoNN>::value, "struct wrapper is not a standard layout!" );
@@ -64572,55 +58545,30 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
 
-  namespace layout
-  {
-    struct WaylandSurfaceCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(),
-                                                        struct wl_display* display_ = nullptr,
-                                                        struct wl_surface* surface_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , display( display_ )
-        , surface( surface_ )
-      {}
-
-      WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this) = rhs;
-      }
-
-      WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct WaylandSurfaceCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(),
                                                       struct wl_display* display_ = nullptr,
                                                       struct wl_surface* surface_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::WaylandSurfaceCreateInfoKHR( flags_, display_, surface_ )
+      : flags( flags_ )
+      , display( display_ )
+      , surface( surface_ )
     {}
 
+    vk::WaylandSurfaceCreateInfoKHR & operator=( vk::WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::WaylandSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::WaylandSurfaceCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::WaylandSurfaceCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::WaylandSurfaceCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -64672,8 +58620,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::WaylandSurfaceCreateInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<WaylandSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -64681,53 +58633,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct Win32KeyedMutexAcquireReleaseInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : acquireCount( acquireCount_ )
-        , pAcquireSyncs( pAcquireSyncs_ )
-        , pAcquireKeys( pAcquireKeys_ )
-        , pAcquireTimeouts( pAcquireTimeouts_ )
-        , releaseCount( releaseCount_ )
-        , pReleaseSyncs( pReleaseSyncs_ )
-        , pReleaseKeys( pReleaseKeys_ )
-      {}
-
-      Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this) = rhs;
-      }
-
-      Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct Win32KeyedMutexAcquireReleaseInfoKHR
   {
     VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0,
                                                                const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
@@ -64736,16 +58642,29 @@ namespace VULKAN_HPP_NAMESPACE
                                                                uint32_t releaseCount_ = 0,
                                                                const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
                                                                const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::Win32KeyedMutexAcquireReleaseInfoKHR( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeouts_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ )
+      : acquireCount( acquireCount_ )
+      , pAcquireSyncs( pAcquireSyncs_ )
+      , pAcquireKeys( pAcquireKeys_ )
+      , pAcquireTimeouts( pAcquireTimeouts_ )
+      , releaseCount( releaseCount_ )
+      , pReleaseSyncs( pReleaseSyncs_ )
+      , pReleaseKeys( pReleaseKeys_ )
     {}
 
+    vk::Win32KeyedMutexAcquireReleaseInfoKHR & operator=( vk::Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32KeyedMutexAcquireReleaseInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::Win32KeyedMutexAcquireReleaseInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::Win32KeyedMutexAcquireReleaseInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::Win32KeyedMutexAcquireReleaseInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -64825,8 +58744,16 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::Win32KeyedMutexAcquireReleaseInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Win32KeyedMutexAcquireReleaseInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -64834,53 +58761,7 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct Win32KeyedMutexAcquireReleaseInfoNV
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : acquireCount( acquireCount_ )
-        , pAcquireSyncs( pAcquireSyncs_ )
-        , pAcquireKeys( pAcquireKeys_ )
-        , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
-        , releaseCount( releaseCount_ )
-        , pReleaseSyncs( pReleaseSyncs_ )
-        , pReleaseKeys( pReleaseKeys_ )
-      {}
-
-      Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this) = rhs;
-      }
-
-      Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct Win32KeyedMutexAcquireReleaseInfoNV
   {
     VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0,
                                                               const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
@@ -64889,16 +58770,29 @@ namespace VULKAN_HPP_NAMESPACE
                                                               uint32_t releaseCount_ = 0,
                                                               const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
                                                               const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::Win32KeyedMutexAcquireReleaseInfoNV( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeoutMilliseconds_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ )
+      : acquireCount( acquireCount_ )
+      , pAcquireSyncs( pAcquireSyncs_ )
+      , pAcquireKeys( pAcquireKeys_ )
+      , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
+      , releaseCount( releaseCount_ )
+      , pReleaseSyncs( pReleaseSyncs_ )
+      , pReleaseKeys( pReleaseKeys_ )
     {}
 
+    vk::Win32KeyedMutexAcquireReleaseInfoNV & operator=( vk::Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32KeyedMutexAcquireReleaseInfoNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::Win32KeyedMutexAcquireReleaseInfoNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::Win32KeyedMutexAcquireReleaseInfoNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::Win32KeyedMutexAcquireReleaseInfoNV const *>(&rhs);
       return *this;
     }
 
@@ -64978,8 +58872,16 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::Win32KeyedMutexAcquireReleaseInfoNV::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Win32KeyedMutexAcquireReleaseInfoNV>::value, "struct wrapper is not a standard layout!" );
@@ -64987,55 +58889,30 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
-  namespace layout
-  {
-    struct Win32SurfaceCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(),
-                                                      HINSTANCE hinstance_ = 0,
-                                                      HWND hwnd_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , hinstance( hinstance_ )
-        , hwnd( hwnd_ )
-      {}
-
-      Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this) = rhs;
-      }
-
-      Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct Win32SurfaceCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(),
                                                     HINSTANCE hinstance_ = 0,
                                                     HWND hwnd_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::Win32SurfaceCreateInfoKHR( flags_, hinstance_, hwnd_ )
+      : flags( flags_ )
+      , hinstance( hinstance_ )
+      , hwnd( hwnd_ )
     {}
 
+    vk::Win32SurfaceCreateInfoKHR & operator=( vk::Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32SurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::Win32SurfaceCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::Win32SurfaceCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::Win32SurfaceCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -65087,63 +58964,18 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::Win32SurfaceCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
+    const void* pNext = nullptr;
+    vk::Win32SurfaceCreateFlagsKHR flags;
+    HINSTANCE hinstance;
+    HWND hwnd;
   };
   static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<Win32SurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-  namespace layout
-  {
-    struct WriteDescriptorSet
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR 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 ) VULKAN_HPP_NOEXCEPT
-        : dstSet( dstSet_ )
-        , dstBinding( dstBinding_ )
-        , dstArrayElement( dstArrayElement_ )
-        , descriptorCount( descriptorCount_ )
-        , descriptorType( descriptorType_ )
-        , pImageInfo( pImageInfo_ )
-        , pBufferInfo( pBufferInfo_ )
-        , pTexelBufferView( pTexelBufferView_ )
-      {}
-
-      WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkWriteDescriptorSet*>(this) = rhs;
-      }
-
-      WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct WriteDescriptorSet
   {
     VULKAN_HPP_CONSTEXPR WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
                                              uint32_t dstBinding_ = 0,
@@ -65153,16 +58985,30 @@ namespace VULKAN_HPP_NAMESPACE
                                              const vk::DescriptorImageInfo* pImageInfo_ = nullptr,
                                              const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr,
                                              const vk::BufferView* pTexelBufferView_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::WriteDescriptorSet( dstSet_, dstBinding_, dstArrayElement_, descriptorCount_, descriptorType_, pImageInfo_, pBufferInfo_, pTexelBufferView_ )
+      : dstSet( dstSet_ )
+      , dstBinding( dstBinding_ )
+      , dstArrayElement( dstArrayElement_ )
+      , descriptorCount( descriptorCount_ )
+      , descriptorType( descriptorType_ )
+      , pImageInfo( pImageInfo_ )
+      , pBufferInfo( pBufferInfo_ )
+      , pTexelBufferView( pTexelBufferView_ )
     {}
 
+    vk::WriteDescriptorSet & operator=( vk::WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSet ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::WriteDescriptorSet( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::WriteDescriptorSet::operator=(rhs);
+      *this = *reinterpret_cast<vk::WriteDescriptorSet const *>(&rhs);
       return *this;
     }
 
@@ -65249,57 +59095,43 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::WriteDescriptorSet::sType;
+  public:
+    const 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 ), "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:
-      VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
-                                                                      const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : accelerationStructureCount( accelerationStructureCount_ )
-        , pAccelerationStructures( pAccelerationStructures_ )
-      {}
-
-      WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this) = rhs;
-      }
-
-      WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this) = rhs;
-        return *this;
-      }
-
-    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
+  struct WriteDescriptorSetAccelerationStructureNV
   {
     VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
                                                                     const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::WriteDescriptorSetAccelerationStructureNV( accelerationStructureCount_, pAccelerationStructures_ )
+      : accelerationStructureCount( accelerationStructureCount_ )
+      , pAccelerationStructures( pAccelerationStructures_ )
     {}
 
+    vk::WriteDescriptorSetAccelerationStructureNV & operator=( vk::WriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSetAccelerationStructureNV ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::WriteDescriptorSetAccelerationStructureNV( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::WriteDescriptorSetAccelerationStructureNV::operator=(rhs);
+      *this = *reinterpret_cast<vk::WriteDescriptorSetAccelerationStructureNV const *>(&rhs);
       return *this;
     }
 
@@ -65344,57 +59176,37 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::WriteDescriptorSetAccelerationStructureNV::sType;
+  public:
+    const vk::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV;
+    const void* pNext = nullptr;
+    uint32_t accelerationStructureCount;
+    const vk::AccelerationStructureNV* pAccelerationStructures;
   };
   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:
-      VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
-                                                                    const void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-        : dataSize( dataSize_ )
-        , pData( pData_ )
-      {}
-
-      WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this) = rhs;
-      }
-
-      WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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 : public layout::WriteDescriptorSetInlineUniformBlockEXT
+  struct WriteDescriptorSetInlineUniformBlockEXT
   {
     VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
                                                                   const void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT
-      : layout::WriteDescriptorSetInlineUniformBlockEXT( dataSize_, pData_ )
+      : dataSize( dataSize_ )
+      , pData( pData_ )
     {}
 
+    vk::WriteDescriptorSetInlineUniformBlockEXT & operator=( vk::WriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSetInlineUniformBlockEXT ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::WriteDescriptorSetInlineUniformBlockEXT( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::WriteDescriptorSetInlineUniformBlockEXT::operator=(rhs);
+      *this = *reinterpret_cast<vk::WriteDescriptorSetInlineUniformBlockEXT const *>(&rhs);
       return *this;
     }
 
@@ -65439,63 +59251,41 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::WriteDescriptorSetInlineUniformBlockEXT::sType;
+  public:
+    const vk::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
+    const void* pNext = nullptr;
+    uint32_t dataSize;
+    const void* pData;
   };
   static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<WriteDescriptorSetInlineUniformBlockEXT>::value, "struct wrapper is not a standard layout!" );
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
 
-  namespace layout
-  {
-    struct XcbSurfaceCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(),
-                                                    xcb_connection_t* connection_ = nullptr,
-                                                    xcb_window_t window_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , connection( connection_ )
-        , window( window_ )
-      {}
-
-      XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this) = rhs;
-      }
-
-      XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct XcbSurfaceCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(),
                                                   xcb_connection_t* connection_ = nullptr,
                                                   xcb_window_t window_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::XcbSurfaceCreateInfoKHR( flags_, connection_, window_ )
+      : flags( flags_ )
+      , connection( connection_ )
+      , window( window_ )
     {}
 
+    vk::XcbSurfaceCreateInfoKHR & operator=( vk::XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::XcbSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::XcbSurfaceCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::XcbSurfaceCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::XcbSurfaceCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -65547,8 +59337,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::XcbSurfaceCreateInfoKHR::sType;
+  public:
+    const 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 ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<XcbSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -65556,55 +59350,30 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
 
-  namespace layout
-  {
-    struct XlibSurfaceCreateInfoKHR
-    {
-    protected:
-      VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(),
-                                                     Display* dpy_ = nullptr,
-                                                     Window window_ = 0 ) VULKAN_HPP_NOEXCEPT
-        : flags( flags_ )
-        , dpy( dpy_ )
-        , window( window_ )
-      {}
-
-      XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this) = rhs;
-      }
-
-      XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      {
-        *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
+  struct XlibSurfaceCreateInfoKHR
   {
     VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(),
                                                    Display* dpy_ = nullptr,
                                                    Window window_ = 0 ) VULKAN_HPP_NOEXCEPT
-      : layout::XlibSurfaceCreateInfoKHR( flags_, dpy_, window_ )
+      : flags( flags_ )
+      , dpy( dpy_ )
+      , window( window_ )
     {}
 
+    vk::XlibSurfaceCreateInfoKHR & operator=( vk::XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext, &rhs.pNext, sizeof( vk::XlibSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) );
+      return *this;
+    }
+
     XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
-      : layout::XlibSurfaceCreateInfoKHR( rhs )
-    {}
+    {
+      *this = rhs;
+    }
 
     XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      layout::XlibSurfaceCreateInfoKHR::operator=(rhs);
+      *this = *reinterpret_cast<vk::XlibSurfaceCreateInfoKHR const *>(&rhs);
       return *this;
     }
 
@@ -65656,8 +59425,12 @@ namespace VULKAN_HPP_NAMESPACE
       return !operator==( rhs );
     }
 
-  private:
-    using layout::XlibSurfaceCreateInfoKHR::sType;
+  public:
+    const vk::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
+    const void* pNext = nullptr;
+    vk::XlibSurfaceCreateFlagsKHR flags;
+    Display* dpy;
+    Window window;
   };
   static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   static_assert( std::is_standard_layout<XlibSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
@@ -67224,6 +60997,20 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR( const vk::AcquireProfilingLockInfoKHR* pInfo, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>( pInfo ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>( &info ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireProfilingLockKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
   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 ) ) );
@@ -70755,6 +64542,17 @@ namespace VULKAN_HPP_NAMESPACE
     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" );
   }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type Device::registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    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 ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Fence,Dispatch>( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXTUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -70770,6 +64568,17 @@ namespace VULKAN_HPP_NAMESPACE
     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" );
   }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type Device::registerDisplayEventEXTUnique( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    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 ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Fence,Dispatch>( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXTUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -70828,6 +64637,20 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR(Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkReleaseProfilingLockKHR( m_device );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR(Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkReleaseProfilingLockKHR( m_device );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
   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 ) ) );
@@ -72007,6 +65830,58 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, uint32_t* pCounterCount, vk::PerformanceCounterKHR* pCounters, vk::PerformanceCounterDescriptionKHR* pCounterDescriptions, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, pCounterCount, reinterpret_cast<VkPerformanceCounterKHR*>( pCounters ), reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( pCounterDescriptions ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR,Allocator>>::type PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy<vk::PerformanceCounterKHR> counters, Dispatch const &d ) const
+  {
+    std::vector<PerformanceCounterDescriptionKHR,Allocator> counterDescriptions;
+    uint32_t counterCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast<VkPerformanceCounterKHR*>( counters.data() ), nullptr ) );
+      if ( ( result == Result::eSuccess ) && counterCount )
+      {
+        counterDescriptions.resize( counterCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast<VkPerformanceCounterKHR*>( counters.data() ), reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( counterDescriptions.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() );
+      counterDescriptions.resize( counterCount );
+    }
+    return createResultValue( result, counterDescriptions, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR,Allocator>>::type PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy<vk::PerformanceCounterKHR> counters, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<PerformanceCounterDescriptionKHR,Allocator> counterDescriptions( vectorAllocator );
+    uint32_t counterCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast<VkPerformanceCounterKHR*>( counters.data() ), nullptr ) );
+      if ( ( result == Result::eSuccess ) && counterCount )
+      {
+        counterDescriptions.resize( counterCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast<VkPerformanceCounterKHR*>( counters.data() ), reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( counterDescriptions.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() );
+      counterDescriptions.resize( counterCount );
+    }
+    return createResultValue( result, counterDescriptions, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
   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 ) ) );
@@ -72997,6 +66872,21 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const vk::QueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( m_physicalDevice, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>( pPerformanceQueryCreateInfo ), pNumPasses );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
+  {
+    uint32_t numPasses;
+    d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( m_physicalDevice, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>( &performanceQueryCreateInfo ), &numPasses );
+    return numPasses;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
   VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
   {
     d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
@@ -73057,7 +66947,16 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t queueFamilyPropertyCount;
     d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
     queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    std::vector<vk::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+    {
+      localVector[i].pNext = queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>().pNext;
+    }
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+    {
+      queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>() = localVector[i];
+    }
     return queueFamilyProperties;
   }
   template<typename StructureChain, typename Allocator, typename Dispatch>
@@ -73067,7 +66966,16 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t queueFamilyPropertyCount;
     d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
     queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    std::vector<vk::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+    {
+      localVector[i].pNext = queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>().pNext;
+    }
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+    {
+      queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>() = localVector[i];
+    }
     return queueFamilyProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -73105,7 +67013,16 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t queueFamilyPropertyCount;
     d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
     queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    std::vector<vk::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+    {
+      localVector[i].pNext = queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>().pNext;
+    }
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+    {
+      queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>() = localVector[i];
+    }
     return queueFamilyProperties;
   }
   template<typename StructureChain, typename Allocator, typename Dispatch>
@@ -73115,7 +67032,16 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t queueFamilyPropertyCount;
     d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
     queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    std::vector<vk::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+    {
+      localVector[i].pNext = queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>().pNext;
+    }
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+    for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+    {
+      queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>() = localVector[i];
+    }
     return queueFamilyProperties;
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -73857,6 +67783,7 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryDedicatedAllocateInfo>{ enum { value = true }; };
   template <> struct isStructureChainValid<MemoryRequirements2, MemoryDedicatedRequirements>{ enum { value = true }; };
   template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryPriorityAllocateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SubmitInfo, PerformanceQuerySubmitInfoKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevice16BitStorageFeatures>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevice16BitStorageFeatures>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevice8BitStorageFeaturesKHR>{ enum { value = true }; };
@@ -73932,6 +67859,9 @@ 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, PhysicalDevicePerformanceQueryFeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevicePerformanceQueryFeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePerformanceQueryPropertiesKHR>{ 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 }; };
@@ -74031,6 +67961,7 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<PresentInfoKHR, PresentRegionsKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; };
   template <> struct isStructureChainValid<SubmitInfo, ProtectedSubmitInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<QueryPoolCreateInfo, QueryPoolPerformanceCreateInfoKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<QueueFamilyProperties2, QueueFamilyCheckpointPropertiesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassAttachmentBeginInfoKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassFragmentDensityMapCreateInfoEXT>{ enum { value = true }; };
@@ -74076,10 +68007,6 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetAccelerationStructureNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetInlineUniformBlockEXT>{ enum { value = true }; };
 
-#if !defined(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL)
-# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL  1
-#endif
-
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
   class DynamicLoader
   {
@@ -74095,7 +68022,7 @@ namespace VULKAN_HPP_NAMESPACE
 #elif defined(__APPLE__)
       m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
 #elif defined(_WIN32)
-      m_library = LoadLibrary( "vulkan-1.dll" );
+      m_library = LoadLibrary( TEXT( "vulkan-1.dll" ) );
 #else
       assert( false && "unsupported platform" );
 #endif
@@ -74255,6 +68182,7 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0;
     PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
     PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
+    PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0;
     PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0;
     PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
     PFN_vkAllocateMemory vkAllocateMemory = 0;
@@ -74426,6 +68354,7 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0;
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
     PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0;
+    PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0;
     PFN_vkResetCommandPool vkResetCommandPool = 0;
     PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
     PFN_vkResetEvent vkResetEvent = 0;
@@ -74501,6 +68430,7 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0;
     PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0;
     PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0;
+    PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
     PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0;
     PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0;
     PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0;
@@ -74537,6 +68467,7 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0;
     PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0;
     PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0;
+    PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0;
     PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0;
     PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0;
     PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0;
@@ -74630,8 +68561,9 @@ namespace VULKAN_HPP_NAMESPACE
       }
     }
 
-    void init( vk::Instance instance ) VULKAN_HPP_NOEXCEPT
+    void init( vk::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
     {
+      VkInstance instance = static_cast<VkInstance>(instanceCpp);
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
       vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
@@ -74685,6 +68617,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
       vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
       vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
+      vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
       vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
       vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) );
       vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) );
@@ -74721,6 +68654,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
       vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
       vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) );
+      vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
       vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
       vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
       vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) );
@@ -74856,6 +68790,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
       vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
       vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
+      vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) );
       vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
       vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
       vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
@@ -75027,6 +68962,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
       vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
+      vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) );
       vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
       vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
       vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
@@ -75059,8 +68995,9 @@ namespace VULKAN_HPP_NAMESPACE
       vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
     }
 
-    void init( vk::Device device ) VULKAN_HPP_NOEXCEPT
+    void init( vk::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
     {
+      VkDevice device = static_cast<VkDevice>(deviceCpp);
       vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
       vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
       vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
@@ -75163,6 +69100,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
       vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
       vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
+      vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
       vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
       vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
       vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
@@ -75334,6 +69272,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
       vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
+      vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
       vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
       vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
       vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 5f7c485..246ae72 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -44,7 +44,7 @@ extern "C" {
 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
 // Version of this file
-#define VK_HEADER_VERSION 127
+#define VK_HEADER_VERSION 128
 
 
 #define VK_NULL_HANDLE 0
@@ -370,6 +370,13 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
     VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
     VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
+    VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
+    VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
+    VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
+    VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,
+    VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
     VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
@@ -951,6 +958,7 @@ typedef enum VkQueryType {
     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
     VK_QUERY_TYPE_TIMESTAMP = 2,
     VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
+    VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
     VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
     VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
@@ -1691,10 +1699,11 @@ typedef enum VkPipelineCreateFlagBits {
     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
-    VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
+    VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 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_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
     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
@@ -5915,6 +5924,150 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
 #endif
 
 
+#define VK_KHR_performance_query 1
+#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
+#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
+
+typedef enum VkPerformanceCounterUnitKHR {
+    VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
+    VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
+    VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
+    VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
+    VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
+    VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
+    VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
+    VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
+    VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
+    VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
+    VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
+    VK_PERFORMANCE_COUNTER_UNIT_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR,
+    VK_PERFORMANCE_COUNTER_UNIT_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR,
+    VK_PERFORMANCE_COUNTER_UNIT_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR + 1),
+    VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterUnitKHR;
+
+typedef enum VkPerformanceCounterScopeKHR {
+    VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = 0,
+    VK_QUERY_SCOPE_RENDER_PASS_KHR = 1,
+    VK_QUERY_SCOPE_COMMAND_KHR = 2,
+    VK_PERFORMANCE_COUNTER_SCOPE_BEGIN_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR,
+    VK_PERFORMANCE_COUNTER_SCOPE_END_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_KHR,
+    VK_PERFORMANCE_COUNTER_SCOPE_RANGE_SIZE_KHR = (VK_QUERY_SCOPE_COMMAND_KHR - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR + 1),
+    VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterScopeKHR;
+
+typedef enum VkPerformanceCounterStorageKHR {
+    VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
+    VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
+    VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
+    VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
+    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
+    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
+    VK_PERFORMANCE_COUNTER_STORAGE_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR,
+    VK_PERFORMANCE_COUNTER_STORAGE_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR,
+    VK_PERFORMANCE_COUNTER_STORAGE_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR + 1),
+    VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterStorageKHR;
+
+typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 0x00000001,
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 0x00000002,
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterDescriptionFlagBitsKHR;
+typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
+
+typedef enum VkAcquireProfilingLockFlagBitsKHR {
+    VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkAcquireProfilingLockFlagBitsKHR;
+typedef VkFlags VkAcquireProfilingLockFlagsKHR;
+typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           performanceCounterQueryPools;
+    VkBool32           performanceCounterMultipleQueryPools;
+} VkPhysicalDevicePerformanceQueryFeaturesKHR;
+
+typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           allowCommandBufferQueryCopies;
+} VkPhysicalDevicePerformanceQueryPropertiesKHR;
+
+typedef struct VkPerformanceCounterKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkPerformanceCounterUnitKHR       unit;
+    VkPerformanceCounterScopeKHR      scope;
+    VkPerformanceCounterStorageKHR    storage;
+    uint8_t                           uuid[VK_UUID_SIZE];
+} VkPerformanceCounterKHR;
+
+typedef struct VkPerformanceCounterDescriptionKHR {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    VkPerformanceCounterDescriptionFlagsKHR    flags;
+    char                                       name[VK_MAX_DESCRIPTION_SIZE];
+    char                                       category[VK_MAX_DESCRIPTION_SIZE];
+    char                                       description[VK_MAX_DESCRIPTION_SIZE];
+} VkPerformanceCounterDescriptionKHR;
+
+typedef struct VkQueryPoolPerformanceCreateInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           queueFamilyIndex;
+    uint32_t           counterIndexCount;
+    const uint32_t*    pCounterIndices;
+} VkQueryPoolPerformanceCreateInfoKHR;
+
+typedef union VkPerformanceCounterResultKHR {
+    int32_t     int32;
+    int64_t     int64;
+    uint32_t    uint32;
+    uint64_t    uint64;
+    float       float32;
+    double      float64;
+} VkPerformanceCounterResultKHR;
+
+typedef struct VkAcquireProfilingLockInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkAcquireProfilingLockFlagsKHR    flags;
+    uint64_t                          timeout;
+} VkAcquireProfilingLockInfoKHR;
+
+typedef struct VkPerformanceQuerySubmitInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           counterPassIndex;
+} VkPerformanceQuerySubmitInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
+typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    uint32_t*                                   pCounterCount,
+    VkPerformanceCounterKHR*                    pCounters,
+    VkPerformanceCounterDescriptionKHR*         pCounterDescriptions);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
+    uint32_t*                                   pNumPasses);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(
+    VkDevice                                    device,
+    const VkAcquireProfilingLockInfoKHR*        pInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(
+    VkDevice                                    device);
+#endif
+
+
 #define VK_KHR_maintenance2 1
 #define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
@@ -7178,7 +7331,7 @@ typedef struct VkValidationFlagsEXT {
 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
     VkStructureType    sType;
-    const void*        pNext;
+    void*              pNext;
     VkBool32           textureCompressionASTC_HDR;
 } VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
 
diff --git a/registry/validusage.json b/registry/validusage.json
index f9331ef..4a18fdc 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.1.127",
-    "comment": "from git branch: github-master commit: fa497b29d87078e1fee7372e369e9a1a788d6358",
-    "date": "2019-11-04 06:40:43Z"
+    "api version": "1.1.128",
+    "comment": "from git branch: github-master commit: d4b6925d02d0c917403fb8743c0289dd67b027f1",
+    "date": "2019-11-17 15:45:54Z"
   },
   "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=\"#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=\"#VkPhysicalDeviceTimelineSemaphorePropertiesKHR\">VkPhysicalDeviceTimelineSemaphorePropertiesKHR</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=\"#VkPhysicalDevicePerformanceQueryPropertiesKHR\">VkPhysicalDevicePerformanceQueryPropertiesKHR</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=\"#VkPhysicalDeviceTimelineSemaphorePropertiesKHR\">VkPhysicalDeviceTimelineSemaphorePropertiesKHR</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackPropertiesEXT\">VkPhysicalDeviceTransformFeedbackPropertiesEXT</a>, or <a href=\"#VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\">VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</a>"
         },
         {
           "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique",
@@ -298,6 +298,50 @@
         }
       ]
     },
+    "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter",
+          "text": " <code>physicalDevice</code> <strong class=\"purple\">must</strong> be a valid <code>VkPhysicalDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounterCount-parameter",
+          "text": " <code>pCounterCount</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>uint32_t</code> value"
+        },
+        {
+          "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounters-parameter",
+          "text": " If the value referenced by <code>pCounterCount</code> is not <code>0</code>, and <code>pCounters</code> is not <code>NULL</code>, <code>pCounters</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pCounterCount</code> <code>VkPerformanceCounterKHR</code> structures"
+        },
+        {
+          "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounterDescriptions-parameter",
+          "text": " If the value referenced by <code>pCounterCount</code> is not <code>0</code>, and <code>pCounterDescriptions</code> is not <code>NULL</code>, <code>pCounterDescriptions</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>pCounterCount</code> <code>VkPerformanceCounterDescriptionKHR</code> structures"
+        }
+      ]
+    },
+    "VkPerformanceCounterKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-VkPerformanceCounterKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkPerformanceCounterKHR-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        }
+      ]
+    },
+    "VkPerformanceCounterDescriptionKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-VkPerformanceCounterDescriptionKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkPerformanceCounterDescriptionKHR-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        }
+      ]
+    },
     "vkEnumeratePhysicalDeviceGroups": {
       "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [
         {
@@ -388,7 +432,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=\"#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=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64FeaturesKHR\">VkPhysicalDeviceShaderAtomicInt64FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</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=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeaturesKHR\">VkPhysicalDeviceTimelineSemaphoreFeaturesKHR</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=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</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=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64FeaturesKHR\">VkPhysicalDeviceShaderAtomicInt64FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</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=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeaturesKHR\">VkPhysicalDeviceTimelineSemaphoreFeaturesKHR</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",
@@ -1005,6 +1049,10 @@
           "text": " If any element of <code>pSubmits</code>-&gt;<code>pCommandBuffers</code> includes a <a href=\"#synchronization-queue-transfers-acquire\">Queue Family Transfer Acquire Operation</a>, there <strong class=\"purple\">must</strong> exist a previously submitted <a href=\"#synchronization-queue-transfers-release\">Queue Family Transfer Release Operation</a> on a queue in the queue family identified by the acquire operation, with parameters matching the acquire operation as defined in the definition of such <a href=\"#synchronization-queue-transfers-acquire\">acquire operations</a>, and which happens before the acquire operation."
         },
         {
+          "vuid": "VUID-vkQueueSubmit-pSubmits-02808",
+          "text": " Any resource created with <code>VK_SHARING_MODE_EXCLUSIVE</code> that is read by an operation specified by <code>pSubmits</code> <strong class=\"purple\">must</strong> not be owned by any queue family other than the one which <code>queue</code> belongs to, at the time it is executed"
+        },
+        {
           "vuid": "VUID-vkQueueSubmit-queue-parameter",
           "text": " <code>queue</code> <strong class=\"purple\">must</strong> be a valid <code>VkQueue</code> handle"
         },
@@ -1026,6 +1074,12 @@
           "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-03238",
           "text": " All elements of the <code>pWaitSemaphores</code> member of all elements of <code>pSubmits</code> created with a <a href=\"#VkSemaphoreTypeKHR\">VkSemaphoreTypeKHR</a> of <code>VK_SEMAPHORE_TYPE_BINARY_KHR</code> <strong class=\"purple\">must</strong> reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) <strong class=\"purple\">must</strong> have also been submitted for execution."
         }
+      ],
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkQueueSubmit-pCommandBuffers-03220",
+          "text": " If a command recorded into any element of <code>pCommandBuffers</code> was a <a href=\"#vkCmdBeginQuery\">vkCmdBeginQuery</a> whose <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <a href=\"#profiling-lock\">profiling lock</a> <strong class=\"purple\">must</strong> have been held continuously on the <code>VkDevice</code> that <code>queue</code> was retrieved from, throughout recording of those command buffers."
+        }
       ]
     },
     "VkSubmitInfo": {
@@ -1052,7 +1106,7 @@
         },
         {
           "vuid": "VUID-VkSubmitInfo-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=\"#VkD3D12FenceSubmitInfoKHR\">VkD3D12FenceSubmitInfoKHR</a>, <a href=\"#VkDeviceGroupSubmitInfo\">VkDeviceGroupSubmitInfo</a>, <a href=\"#VkProtectedSubmitInfo\">VkProtectedSubmitInfo</a>, <a href=\"#VkTimelineSemaphoreSubmitInfoKHR\">VkTimelineSemaphoreSubmitInfoKHR</a>, <a href=\"#VkWin32KeyedMutexAcquireReleaseInfoKHR\">VkWin32KeyedMutexAcquireReleaseInfoKHR</a>, or <a href=\"#VkWin32KeyedMutexAcquireReleaseInfoNV\">VkWin32KeyedMutexAcquireReleaseInfoNV</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=\"#VkD3D12FenceSubmitInfoKHR\">VkD3D12FenceSubmitInfoKHR</a>, <a href=\"#VkDeviceGroupSubmitInfo\">VkDeviceGroupSubmitInfo</a>, <a href=\"#VkPerformanceQuerySubmitInfoKHR\">VkPerformanceQuerySubmitInfoKHR</a>, <a href=\"#VkProtectedSubmitInfo\">VkProtectedSubmitInfo</a>, <a href=\"#VkTimelineSemaphoreSubmitInfoKHR\">VkTimelineSemaphoreSubmitInfoKHR</a>, <a href=\"#VkWin32KeyedMutexAcquireReleaseInfoKHR\">VkWin32KeyedMutexAcquireReleaseInfoKHR</a>, or <a href=\"#VkWin32KeyedMutexAcquireReleaseInfoNV\">VkWin32KeyedMutexAcquireReleaseInfoNV</a>"
         },
         {
           "vuid": "VUID-VkSubmitInfo-sType-unique",
@@ -1292,6 +1346,18 @@
         }
       ]
     },
+    "VkPerformanceQuerySubmitInfoKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-VkPerformanceQuerySubmitInfoKHR-counterPassIndex-03221",
+          "text": " <code>counterPassIndex</code> <strong class=\"purple\">must</strong> be less than the number of counter passes required by any queries within the batch. The required number of counter passes for a performance query is obtained by calling <a href=\"#vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\">vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR</a>."
+        },
+        {
+          "vuid": "VUID-VkPerformanceQuerySubmitInfoKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR</code>"
+        }
+      ]
+    },
     "vkCmdExecuteCommands": {
       "core": [
         {
@@ -1344,7 +1410,7 @@
         },
         {
           "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00099",
-          "text": " If <code>vkCmdExecuteCommands</code> is being called within a render pass instance, and any element of <code>pCommandBuffers</code> was recorded with <code>VkCommandBufferInheritanceInfo</code>::<code>framebuffer</code> not equal to <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, that <code>VkFramebuffer</code> <strong class=\"purple\">must</strong> match the <code>VkFramebuffer</code> used in the current render pass instance"
+          "text": " If <code>vkCmdExecuteCommands</code> is being called within a render pass instance, and any element of <code>pCommandBuffers</code> was recorded with <a href=\"#VkCommandBufferInheritanceInfo\">VkCommandBufferInheritanceInfo</a>::<code>framebuffer</code> not equal to <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>, that <code>VkFramebuffer</code> <strong class=\"purple\">must</strong> match the <code>VkFramebuffer</code> used in the current render pass instance"
         },
         {
           "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00100",
@@ -2721,6 +2787,30 @@
           "text": " The <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> members of any element of <code>pBufferMemoryBarriers</code> or <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> be equal."
         },
         {
+          "vuid": "VUID-vkCmdWaitEvents-srcAccessMask-02809",
+          "text": " The <code>srcAccessMask</code> member of each element of <code>pMemoryBarriers</code> <strong class=\"purple\">must</strong> only include access flags that are supported by one or more of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdWaitEvents-dstAccessMask-02810",
+          "text": " The <code>dstAccessMask</code> member of each element of <code>pMemoryBarriers</code> <strong class=\"purple\">must</strong> only include access flags that are supported by one or more of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdWaitEvents-srcAccessMask-02811",
+          "text": " The <code>srcAccessMask</code> member of each element of <code>pBufferMemoryBarriers</code> <strong class=\"purple\">must</strong> only include access flags that are supported by one or more of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdWaitEvents-dstAccessMask-02812",
+          "text": " The <code>dstAccessMask</code> member of each element of <code>pBufferMemoryBarriers</code> <strong class=\"purple\">must</strong> only include access flags that are supported by one or more of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdWaitEvents-srcAccessMask-02813",
+          "text": " The <code>srcAccessMask</code> member of each element of <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> only include access flags that are supported by one or more of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdWaitEvents-dstAccessMask-02814",
+          "text": " The <code>dstAccessMask</code> member of any element of <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> only include access flags that are supported by one or more of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
           "vuid": "VUID-vkCmdWaitEvents-commandBuffer-parameter",
           "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkCommandBuffer</code> handle"
         },
@@ -2834,15 +2924,31 @@
         },
         {
           "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01183",
-          "text": " Any pipeline stage included in <code>srcStageMask</code> or <code>dstStageMask</code> <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>."
+          "text": " Any pipeline stage included in <code>srcStageMask</code> or <code>dstStageMask</code> <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
         },
         {
-          "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184",
-          "text": " Each element of <code>pMemoryBarriers</code>, <code>pBufferMemoryBarriers</code> and <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> not have any access flag included in its <code>srcAccessMask</code> member if that bit is not supported by any of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>."
+          "vuid": "VUID-vkCmdPipelineBarrier-srcAccessMask-02815",
+          "text": " The <code>srcAccessMask</code> member of each element of <code>pMemoryBarriers</code> <strong class=\"purple\">must</strong> only include access flags that are supported by one or more of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
         },
         {
-          "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185",
-          "text": " Each element of <code>pMemoryBarriers</code>, <code>pBufferMemoryBarriers</code> and <code>pImageMemoryBarriers</code> <strong class=\"purple\">must</strong> not have any access flag included in its <code>dstAccessMask</code> member if that bit is not supported by any of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>."
+          "vuid": "VUID-vkCmdPipelineBarrier-dstAccessMask-02816",
+          "text": " The <code>dstAccessMask</code> member of each element of <code>pMemoryBarriers</code> <strong class=\"purple\">must</strong> only include access flags that are supported by one or more of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02817",
+          "text": " For any element of <code>pBufferMemoryBarriers</code>, if its <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> members are equal, or if its <code>srcQueueFamilyIndex</code> is the queue family index that was used to create the command pool that <code>commandBuffer</code> was allocated from, then its <code>srcAccessMask</code> member <strong class=\"purple\">must</strong> only contain access flags that are supported by one or more of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02818",
+          "text": " For any element of <code>pBufferMemoryBarriers</code>, if its <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> members are equal, or if its <code>dstQueueFamilyIndex</code> is the queue family index that was used to create the command pool that <code>commandBuffer</code> was allocated from, then its <code>dstAccessMask</code> member <strong class=\"purple\">must</strong> only contain access flags that are supported by one or more of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02819",
+          "text": " For any element of <code>pImageMemoryBarriers</code>, if its <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> members are equal, or if its <code>srcQueueFamilyIndex</code> is the queue family index that was used to create the command pool that <code>commandBuffer</code> was allocated from, then its <code>srcAccessMask</code> member <strong class=\"purple\">must</strong> only contain access flags that are supported by one or more of the pipeline stages in <code>srcStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02820",
+          "text": " For any element of <code>pImageMemoryBarriers</code>, if its <code>srcQueueFamilyIndex</code> and <code>dstQueueFamilyIndex</code> members are equal, or if its <code>dstQueueFamilyIndex</code> is the queue family index that was used to create the command pool that <code>commandBuffer</code> was allocated from, then its <code>dstAccessMask</code> member <strong class=\"purple\">must</strong> only contain access flags that are supported by one or more of the pipeline stages in <code>dstStageMask</code>, as specified in the <a href=\"#synchronization-access-types-supported\">table of supported access types</a>"
         },
         {
           "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-parameter",
@@ -2985,14 +3091,6 @@
           "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
         },
         {
-          "vuid": "VUID-VkBufferMemoryBarrier-srcAccessMask-parameter",
-          "text": " <code>srcAccessMask</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkAccessFlagBits\">VkAccessFlagBits</a> values"
-        },
-        {
-          "vuid": "VUID-VkBufferMemoryBarrier-dstAccessMask-parameter",
-          "text": " <code>dstAccessMask</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkAccessFlagBits\">VkAccessFlagBits</a> values"
-        },
-        {
           "vuid": "VUID-VkBufferMemoryBarrier-buffer-parameter",
           "text": " <code>buffer</code> <strong class=\"purple\">must</strong> be a valid <code>VkBuffer</code> handle"
         }
@@ -3097,14 +3195,6 @@
           "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkSampleLocationsInfoEXT\">VkSampleLocationsInfoEXT</a>"
         },
         {
-          "vuid": "VUID-VkImageMemoryBarrier-srcAccessMask-parameter",
-          "text": " <code>srcAccessMask</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkAccessFlagBits\">VkAccessFlagBits</a> values"
-        },
-        {
-          "vuid": "VUID-VkImageMemoryBarrier-dstAccessMask-parameter",
-          "text": " <code>dstAccessMask</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkAccessFlagBits\">VkAccessFlagBits</a> values"
-        },
-        {
           "vuid": "VUID-VkImageMemoryBarrier-oldLayout-parameter",
           "text": " <code>oldLayout</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkImageLayout\">VkImageLayout</a> value"
         },
@@ -3323,6 +3413,10 @@
           "text": " Each <code>sType</code> member in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be unique"
         },
         {
+          "vuid": "VUID-VkRenderPassCreateInfo-flags-zerobitmask",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+        },
+        {
           "vuid": "VUID-VkRenderPassCreateInfo-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>VkAttachmentDescription</code> structures"
         },
@@ -3895,6 +3989,10 @@
           "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkRenderPassFragmentDensityMapCreateInfoEXT\">VkRenderPassFragmentDensityMapCreateInfoEXT</a>"
         },
         {
+          "vuid": "VUID-VkRenderPassCreateInfo2KHR-flags-zerobitmask",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+        },
+        {
           "vuid": "VUID-VkRenderPassCreateInfo2KHR-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>VkAttachmentDescription2KHR</code> structures"
         },
@@ -5307,8 +5405,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-parameter",
-          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkShaderModuleCreateFlagBits\">VkShaderModuleCreateFlagBits</a> values"
+          "vuid": "VUID-VkShaderModuleCreateInfo-flags-zerobitmask",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
         },
         {
           "vuid": "VUID-VkShaderModuleCreateInfo-pCode-parameter",
@@ -7062,7 +7160,7 @@
       "core": [
         {
           "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01713",
-          "text": " <code>pAllocateInfo</code>-&gt;<code>allocationSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryHeaps</code>[<code>pAllocateInfo</code>-&gt;<code>memoryTypeIndex</code>].<code>size</code> as returned by <a href=\"#vkGetPhysicalDeviceMemoryProperties\">vkGetPhysicalDeviceMemoryProperties</a> for the <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> that <code>device</code> was created from."
+          "text": " <code>pAllocateInfo</code>-&gt;<code>allocationSize</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryHeaps</code>[<code>memindex</code>].<code>size</code> where <code>memindex</code> = <a href=\"#VkPhysicalDeviceMemoryProperties\">VkPhysicalDeviceMemoryProperties</a>::<code>memoryTypes</code>[<code>pAllocateInfo</code>-&gt;<code>memoryTypeIndex</code>].<code>heapIndex</code> as returned by <a href=\"#vkGetPhysicalDeviceMemoryProperties\">vkGetPhysicalDeviceMemoryProperties</a> for the <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> that <code>device</code> was created from."
         },
         {
           "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01714",
@@ -8357,10 +8455,6 @@
           "text": " <code>offset</code> <strong class=\"purple\">must</strong> be less than the size of <code>buffer</code>"
         },
         {
-          "vuid": "VUID-VkBufferViewCreateInfo-offset-02749",
-          "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",
           "text": " If <code>range</code> is not equal to <code>VK_WHOLE_SIZE</code>, <code>range</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
         },
@@ -8413,8 +8507,18 @@
           "text": " <code>format</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkFormat\">VkFormat</a> value"
         }
       ],
+      "!(VK_EXT_texel_buffer_alignment)": [
+        {
+          "vuid": "VUID-VkBufferViewCreateInfo-offset-00926",
+          "text": " <code>offset</code> <strong class=\"purple\">must</strong> be a multiple of <code>VkPhysicalDeviceLimits</code>::<code>minTexelBufferOffsetAlignment</code>"
+        }
+      ],
       "(VK_EXT_texel_buffer_alignment)": [
         {
+          "vuid": "VUID-VkBufferViewCreateInfo-offset-02749",
+          "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-buffer-02750",
           "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"
         },
@@ -10969,10 +11073,6 @@
           "text": " If any of <code>addressModeU</code>, <code>addressModeV</code> or <code>addressModeW</code> are <code>VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER</code>, <code>borderColor</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkBorderColor\">VkBorderColor</a> value"
         },
         {
-          "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079",
-          "text": " If the <code><a href=\"#VK_KHR_sampler_mirror_clamp_to_edge\">VK_KHR_sampler_mirror_clamp_to_edge</a></code> extension is not enabled, <code>addressModeU</code>, <code>addressModeV</code> and <code>addressModeW</code> <strong class=\"purple\">must</strong> not be <code>VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE</code>"
-        },
-        {
           "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01080",
           "text": " If <code>compareEnable</code> is <code>VK_TRUE</code>, <code>compareOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCompareOp\">VkCompareOp</a> value"
         },
@@ -11033,6 +11133,12 @@
           "text": " The sampler reduction mode <strong class=\"purple\">must</strong> be set to <code>VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT</code> if <a href=\"#samplers-YCbCr-conversion\">sampler Y&#8217;C<sub>B</sub>C<sub>R</sub> conversion</a> is enabled"
         }
       ],
+      "(VK_KHR_sampler_mirror_clamp_to_edge)": [
+        {
+          "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079",
+          "text": " If the <code><a href=\"#VK_KHR_sampler_mirror_clamp_to_edge\">VK_KHR_sampler_mirror_clamp_to_edge</a></code> extension is not enabled, <code>addressModeU</code>, <code>addressModeV</code> and <code>addressModeW</code> <strong class=\"purple\">must</strong> not be <code>VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE</code>"
+        }
+      ],
       "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [
         {
           "vuid": "VUID-VkSamplerCreateInfo-magFilter-01081",
@@ -12944,7 +13050,7 @@
         },
         {
           "vuid": "VUID-VkQueryPoolCreateInfo-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=\"#VkQueryPoolPerformanceCreateInfoKHR\">VkQueryPoolPerformanceCreateInfoKHR</a>"
         },
         {
           "vuid": "VUID-VkQueryPoolCreateInfo-flags-zerobitmask",
@@ -12954,6 +13060,56 @@
           "vuid": "VUID-VkQueryPoolCreateInfo-queryType-parameter",
           "text": " <code>queryType</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkQueryType\">VkQueryType</a> value"
         }
+      ],
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-VkQueryPoolCreateInfo-queryType-03222",
+          "text": " If <code>queryType</code> is <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <code>pNext</code> chain <strong class=\"purple\">must</strong> contain a structure of type <a href=\"#VkQueryPoolPerformanceCreateInfoKHR\">VkQueryPoolPerformanceCreateInfoKHR</a>"
+        }
+      ]
+    },
+    "VkQueryPoolPerformanceCreateInfoKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-queueFamilyIndex-03236",
+          "text": " <code>queueFamilyIndex</code> <strong class=\"purple\">must</strong> be a valid queue family index of the device."
+        },
+        {
+          "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-performanceCounterQueryPools-03237",
+          "text": " The <a href=\"#features-features-performanceCounterQueryPools\"><code>performanceCounterQueryPools</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-pCounterIndices-03321",
+          "text": " Each element of <code>pCounterIndices</code> <strong class=\"purple\">must</strong> be in the range of counters reported by <code>vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR</code> for the queue family specified in <code>queueFamilyIndex</code>."
+        },
+        {
+          "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-pCounterIndices-parameter",
+          "text": " <code>pCounterIndices</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>counterIndexCount</code> <code>uint32_t</code> values"
+        },
+        {
+          "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-counterIndexCount-arraylength",
+          "text": " <code>counterIndexCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+        }
+      ]
+    },
+    "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter",
+          "text": " <code>physicalDevice</code> <strong class=\"purple\">must</strong> be a valid <code>VkPhysicalDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-pPerformanceQueryCreateInfo-parameter",
+          "text": " <code>pPerformanceQueryCreateInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkQueryPoolPerformanceCreateInfoKHR</code> structure"
+        },
+        {
+          "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-pNumPasses-parameter",
+          "text": " <code>pNumPasses</code> <strong class=\"purple\">must</strong> be a valid pointer to a <code>uint32_t</code> value"
+        }
       ]
     },
     "vkDestroyQueryPool": {
@@ -13140,6 +13296,24 @@
           "vuid": "VUID-vkCmdBeginQuery-queryType-02328",
           "text": " If the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT</code> then <code>VkPhysicalDeviceTransformFeedbackPropertiesEXT</code>::<code>transformFeedbackQueries</code> <strong class=\"purple\">must</strong> be supported"
         }
+      ],
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkCmdBeginQuery-queryPool-03223",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <a href=\"#profiling-lock\">profiling lock</a> <strong class=\"purple\">must</strong> have been held before <a href=\"#vkBeginCommandBuffer\">vkBeginCommandBuffer</a> was called on <code>commandBuffer</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdBeginQuery-queryPool-03224",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> and one of the counters used to create <code>queryPool</code> was <code>VK_QUERY_SCOPE_COMMAND_BUFFER_KHR</code>, the query begin <strong class=\"purple\">must</strong> be the first recorded command in <code>commandBuffer</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdBeginQuery-queryPool-03225",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> and one of the counters used to create <code>queryPool</code> was <code>VK_QUERY_SCOPE_RENDER_PASS_KHR</code>, the begin command <strong class=\"purple\">must</strong> not be recorded within a render pass instance."
+        },
+        {
+          "vuid": "VUID-vkCmdBeginQuery-queryPool-03226",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> and another query pool with a <code>queryType</code> <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> has been used within <code>commandBuffer</code>, its parent primary command buffer or secondary command buffer recorded within the same parent primary command buffer as <code>commandBuffer</code>, the <a href=\"#features-features-performanceCounterMultipleQueryPools\"><code>performanceCounterMultipleQueryPools</code></a> feature <strong class=\"purple\">must</strong> be enabled."
+        }
       ]
     },
     "vkCmdBeginQueryIndexedEXT": {
@@ -13228,6 +13402,24 @@
           "vuid": "VUID-vkCmdBeginQueryIndexedEXT-query-00808",
           "text": " If called within a render pass instance, the sum of <code>query</code> and the number of bits set in the current subpass&#8217;s view mask <strong class=\"purple\">must</strong> be less than or equal to the number of queries in <code>queryPool</code>"
         }
+      ],
+      "(VK_EXT_transform_feedback)+(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03223",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <a href=\"#profiling-lock\">profiling lock</a> <strong class=\"purple\">must</strong> have been held before <a href=\"#vkBeginCommandBuffer\">vkBeginCommandBuffer</a> was called on <code>commandBuffer</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03224",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> and one of the counters used to create <code>queryPool</code> was <code>VK_QUERY_SCOPE_COMMAND_BUFFER_KHR</code>, the query begin <strong class=\"purple\">must</strong> be the first recorded command in <code>commandBuffer</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03225",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> and one of the counters used to create <code>queryPool</code> was <code>VK_QUERY_SCOPE_RENDER_PASS_KHR</code>, the begin command <strong class=\"purple\">must</strong> not be recorded within a render pass instance."
+        },
+        {
+          "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03226",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> and another query pool with a <code>queryType</code> <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> has been used within <code>commandBuffer</code>, its parent primary command buffer or secondary command buffer recorded within the same parent primary command buffer as <code>commandBuffer</code>, the <a href=\"#features-features-performanceCounterMultipleQueryPools\"><code>performanceCounterMultipleQueryPools</code></a> feature <strong class=\"purple\">must</strong> be enabled."
+        }
       ]
     },
     "vkCmdEndQuery": {
@@ -13272,6 +13464,16 @@
           "vuid": "VUID-vkCmdEndQuery-query-00812",
           "text": " If <code>vkCmdEndQuery</code> is called within a render pass instance, the sum of <code>query</code> and the number of bits set in the current subpass&#8217;s view mask <strong class=\"purple\">must</strong> be less than or equal to the number of queries in <code>queryPool</code>"
         }
+      ],
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkCmdEndQuery-queryPool-03227",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> and one or more of the counters used to create <code>queryPool</code> was <code>VK_QUERY_SCOPE_COMMAND_BUFFER_KHR</code>, the <code>vkCmdEndQuery</code> <strong class=\"purple\">must</strong> be the last recorded command in <code>commandBuffer</code>."
+        },
+        {
+          "vuid": "VUID-vkCmdEndQuery-queryPool-03228",
+          "text": " If <code>queryPool</code> was created with a <code>queryType</code> of <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code> and one or more of the counters used to create <code>queryPool</code> was <code>VK_QUERY_SCOPE_RENDER_PASS_KHR</code>, the <code>vkCmdEndQuery</code> <strong class=\"purple\">must</strong> not be recorded within a render pass instance."
+        }
       ]
     },
     "vkCmdEndQueryIndexedEXT": {
@@ -13338,7 +13540,7 @@
         },
         {
           "vuid": "VUID-vkGetQueryPoolResults-flags-00814",
-          "text": " If <code>VK_QUERY_RESULT_64_BIT</code> is not set in <code>flags</code> then <code>pData</code> and <code>stride</code> <strong class=\"purple\">must</strong> be multiples of <code>4</code>"
+          "text": " If <code>VK_QUERY_RESULT_64_BIT</code> is not set in <code>flags</code>"
         },
         {
           "vuid": "VUID-vkGetQueryPoolResults-flags-00815",
@@ -13380,6 +13582,20 @@
           "vuid": "VUID-vkGetQueryPoolResults-queryPool-parent",
           "text": " <code>queryPool</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>"
         }
+      ],
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkGetQueryPoolResults-queryType-03229",
+          "text": " If the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, then <code>pData</code> and <code>stride</code> <strong class=\"purple\">must</strong> be multiples of the size of <a href=\"#VkPerformanceCounterResultKHR\">VkPerformanceCounterResultKHR</a>"
+        },
+        {
+          "vuid": "VUID-vkGetQueryPoolResults-queryType-03230",
+          "text": " If the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, <code>flags</code> <strong class=\"purple\">must</strong> not contain <code>VK_QUERY_RESULT_WITH_AVAILABILITY_BIT</code>, <code>VK_QUERY_RESULT_PARTIAL_BIT</code> or <code>VK_QUERY_RESULT_64_BIT</code>"
+        },
+        {
+          "vuid": "VUID-vkGetQueryPoolResults-queryType-03231",
+          "text": " If the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <code>queryPool</code> <strong class=\"purple\">must</strong> have been recorded once for each pass as retrieved via a call to <a href=\"#vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\">vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR</a>."
+        }
       ]
     },
     "vkCmdCopyQueryPoolResults": {
@@ -13453,6 +13669,20 @@
           "text": " Each of <code>commandBuffer</code>, <code>dstBuffer</code>, and <code>queryPool</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <code>VkDevice</code>"
         }
       ],
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03232",
+          "text": " If the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, <a href=\"#VkPhysicalDevicePerformanceQueryPropertiesKHR\">VkPhysicalDevicePerformanceQueryPropertiesKHR</a>::<code>allowCommandBufferQueryCopies</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03233",
+          "text": " If the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, <code>flags</code> <strong class=\"purple\">must</strong> not contain <code>VK_QUERY_RESULT_WITH_AVAILABILITY_BIT</code>, <code>VK_QUERY_RESULT_PARTIAL_BIT</code> or <code>VK_QUERY_RESULT_64_BIT</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03234",
+          "text": " If the <code>queryType</code> used to create <code>queryPool</code> was <code>VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR</code>, the <code>queryPool</code> <strong class=\"purple\">must</strong> have been submitted once for each pass as retrieved via a call to <a href=\"#vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\">vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR</a>."
+        }
+      ],
       "(VK_INTEL_performance_query)": [
         {
           "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-02734",
@@ -13510,6 +13740,46 @@
         }
       ]
     },
+    "vkAcquireProfilingLockKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkAcquireProfilingLockKHR-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        },
+        {
+          "vuid": "VUID-vkAcquireProfilingLockKHR-pInfo-parameter",
+          "text": " <code>pInfo</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <code>VkAcquireProfilingLockInfoKHR</code> structure"
+        }
+      ]
+    },
+    "VkAcquireProfilingLockInfoKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-VkAcquireProfilingLockInfoKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR</code>"
+        },
+        {
+          "vuid": "VUID-VkAcquireProfilingLockInfoKHR-pNext-pNext",
+          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkAcquireProfilingLockInfoKHR-flags-zerobitmask",
+          "text": " <code>flags</code> <strong class=\"purple\">must</strong> be <code>0</code>"
+        }
+      ]
+    },
+    "vkReleaseProfilingLockKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkReleaseProfilingLockKHR-device-03235",
+          "text": " The profiling lock of <code>device</code> <strong class=\"purple\">must</strong> have been held via a previous successful call to <a href=\"#vkAcquireProfilingLockKHR\">vkAcquireProfilingLockKHR</a>."
+        },
+        {
+          "vuid": "VUID-vkReleaseProfilingLockKHR-device-parameter",
+          "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <code>VkDevice</code> handle"
+        }
+      ]
+    },
     "vkInitializePerformanceApiINTEL": {
       "(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [
         {
@@ -18195,6 +18465,18 @@
           "text": " <code>scissorCount</code> and <code>viewportCount</code> <strong class=\"purple\">must</strong> be identical"
         },
         {
+          "vuid": "VUID-VkPipelineViewportStateCreateInfo-x-02821",
+          "text": " The <code>x</code> and <code>y</code> members of <code>offset</code> member of any element of <code>pScissors</code> <strong class=\"purple\">must</strong> be greater than or equal to <code>0</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportStateCreateInfo-offset-02822",
+          "text": " Evaluation of <span class=\"eq\">(<code>offset.x</code> &#43; <code>extent.width</code>)</span> <strong class=\"purple\">must</strong> not cause a signed integer addition overflow for any element of <code>pScissors</code>"
+        },
+        {
+          "vuid": "VUID-VkPipelineViewportStateCreateInfo-offset-02823",
+          "text": " Evaluation of <span class=\"eq\">(<code>offset.y</code> &#43; <code>extent.height</code>)</span> <strong class=\"purple\">must</strong> not cause a signed integer addition overflow for any element of <code>pScissors</code>"
+        },
+        {
           "vuid": "VUID-VkPipelineViewportStateCreateInfo-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO</code>"
         },
@@ -19024,15 +19306,15 @@
         },
         {
           "vuid": "VUID-vkCmdSetScissor-x-00595",
-          "text": " The <code>x</code> and <code>y</code> members of <code>offset</code> <strong class=\"purple\">must</strong> be greater than or equal to <code>0</code>"
+          "text": " The <code>x</code> and <code>y</code> members of <code>offset</code> member of any element of <code>pScissors</code> <strong class=\"purple\">must</strong> be greater than or equal to <code>0</code>"
         },
         {
           "vuid": "VUID-vkCmdSetScissor-offset-00596",
-          "text": " Evaluation of <span class=\"eq\">(<code>offset.x</code> &#43; <code>extent.width</code>)</span> <strong class=\"purple\">must</strong> not cause a signed integer addition overflow"
+          "text": " Evaluation of <span class=\"eq\">(<code>offset.x</code> &#43; <code>extent.width</code>)</span> <strong class=\"purple\">must</strong> not cause a signed integer addition overflow for any element of <code>pScissors</code>"
         },
         {
           "vuid": "VUID-vkCmdSetScissor-offset-00597",
-          "text": " Evaluation of <span class=\"eq\">(<code>offset.y</code> &#43; <code>extent.height</code>)</span> <strong class=\"purple\">must</strong> not cause a signed integer addition overflow"
+          "text": " Evaluation of <span class=\"eq\">(<code>offset.y</code> &#43; <code>extent.height</code>)</span> <strong class=\"purple\">must</strong> not cause a signed integer addition overflow for any element of <code>pScissors</code>"
         },
         {
           "vuid": "VUID-vkCmdSetScissor-commandBuffer-parameter",
@@ -22201,7 +22483,7 @@
       ]
     },
     "vkGetPhysicalDeviceSurfaceCapabilities2KHR": {
-      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive,VK_KHR_win32_surface)": [
+      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [
         {
           "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pNext-02671",
           "text": " If an instance of <a href=\"#VkSurfaceCapabilitiesFullScreenExclusiveEXT\">VkSurfaceCapabilitiesFullScreenExclusiveEXT</a> is included in the <code>pNext</code> chain of <code>pSurfaceCapabilities</code>, an instance of <a href=\"#VkSurfaceFullScreenExclusiveWin32InfoEXT\">VkSurfaceFullScreenExclusiveWin32InfoEXT</a> <strong class=\"purple\">must</strong> be included in the <code>pNext</code> chain of <code>pSurfaceInfo</code>."
@@ -22223,7 +22505,7 @@
       ]
     },
     "VkPhysicalDeviceSurfaceInfo2KHR": {
-      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface,VK_EXT_full_screen_exclusive)": [
+      "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface+VK_EXT_full_screen_exclusive)": [
         {
           "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-02672",
           "text": " If the <code>pNext</code> chain includes an instance of <a href=\"#VkSurfaceFullScreenExclusiveInfoEXT\">VkSurfaceFullScreenExclusiveInfoEXT</a> with its <code>fullScreenExclusive</code> member set to <code>VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT</code>, and <code>surface</code> was created using <a href=\"#vkCreateWin32SurfaceKHR\">vkCreateWin32SurfaceKHR</a>, an instance of <a href=\"#VkSurfaceFullScreenExclusiveWin32InfoEXT\">VkSurfaceFullScreenExclusiveWin32InfoEXT</a> <strong class=\"purple\">must</strong> be present in the <code>pNext</code> chain"
@@ -22841,7 +23123,7 @@
           "text": " If <code>flags</code> contains <code>VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR</code>, then <code>VkSurfaceProtectedCapabilitiesKHR</code>::<code>supportsProtected</code> <strong class=\"purple\">must</strong> be <code>VK_TRUE</code> in the <a href=\"#VkSurfaceProtectedCapabilitiesKHR\">VkSurfaceProtectedCapabilitiesKHR</a> structure returned by <a href=\"#vkGetPhysicalDeviceSurfaceCapabilities2KHR\">vkGetPhysicalDeviceSurfaceCapabilities2KHR</a> for <code>surface</code>"
         }
       ],
-      "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_full_screen_exclusive,VK_KHR_win32_surface)": [
+      "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [
         {
           "vuid": "VUID-VkSwapchainCreateInfoKHR-pNext-02679",
           "text": " If the <code>pNext</code> chain includes an instance of <a href=\"#VkSurfaceFullScreenExclusiveInfoEXT\">VkSurfaceFullScreenExclusiveInfoEXT</a> with its <code>fullScreenExclusive</code> member set to <code>VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT</code>, and <code>surface</code> was created using <a href=\"#vkCreateWin32SurfaceKHR\">vkCreateWin32SurfaceKHR</a>, an instance of <a href=\"#VkSurfaceFullScreenExclusiveWin32InfoEXT\">VkSurfaceFullScreenExclusiveWin32InfoEXT</a> <strong class=\"purple\">must</strong> be present in the <code>pNext</code> chain"
@@ -24512,6 +24794,22 @@
         }
       ]
     },
+    "VkPhysicalDevicePerformanceQueryFeaturesKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-VkPhysicalDevicePerformanceQueryFeaturesKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR</code>"
+        }
+      ]
+    },
+    "VkPhysicalDevicePerformanceQueryPropertiesKHR": {
+      "(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-VkPhysicalDevicePerformanceQueryPropertiesKHR-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceShadingRateImagePropertiesNV": {
       "(VK_NV_shading_rate_image)": [
         {
diff --git a/registry/vk.xml b/registry/vk.xml
index 20f769c..26ff4cc 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> 127</type>
+#define <name>VK_HEADER_VERSION</name> 128</type>
 
         <type category="define">
 #define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type>
@@ -269,9 +269,11 @@ 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="VkPerformanceCounterDescriptionFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkPerformanceCounterDescriptionFlagsKHR</name>;</type>
+        <type requires="VkAcquireProfilingLockFlagBitsKHR"          category="bitmask">typedef <type>VkFlags</type> <name>VkAcquireProfilingLockFlagsKHR</name>;</type>
+        <type requires="VkSemaphoreWaitFlagBitsKHR"       category="bitmask">typedef <type>VkFlags</type> <name>VkSemaphoreWaitFlagsKHR</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>
-        <type requires="VkSemaphoreWaitFlagBitsKHR"       category="bitmask">typedef <type>VkFlags</type> <name>VkSemaphoreWaitFlagsKHR</name>;</type>
 
             <comment>WSI extensions</comment>
         <type requires="VkCompositeAlphaFlagBitsKHR"      category="bitmask">typedef <type>VkFlags</type> <name>VkCompositeAlphaFlagsKHR</name>;</type>
@@ -338,7 +340,6 @@ typedef void <name>CAMetalLayer</name>;
         <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>
         <type category="handle"><type>VK_DEFINE_HANDLE</type>(<name>VkInstance</name>)</type>
         <type category="handle" parent="VkInstance"><type>VK_DEFINE_HANDLE</type>(<name>VkPhysicalDevice</name>)</type>
@@ -508,6 +509,11 @@ typedef void <name>CAMetalLayer</name>;
         <type name="VkScopeNV" category="enum"/>
         <type name="VkComponentTypeNV" category="enum"/>
         <type name="VkPipelineCreationFeedbackFlagBitsEXT" category="enum"/>
+        <type name="VkPerformanceCounterScopeKHR" category="enum"/>
+        <type name="VkPerformanceCounterUnitKHR" category="enum"/>
+        <type name="VkPerformanceCounterStorageKHR" category="enum"/>
+        <type name="VkPerformanceCounterDescriptionFlagBitsKHR" category="enum"/>
+        <type name="VkAcquireProfilingLockFlagBitsKHR" category="enum"/>
         <type name="VkSemaphoreWaitFlagBitsKHR" category="enum"/>
         <type name="VkPerformanceConfigurationTypeINTEL" category="enum"/>
         <type name="VkQueryPoolSamplingModeINTEL" category="enum"/>
@@ -889,8 +895,8 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkBufferMemoryBarrier">
             <member values="VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*            <name>pNext</name></member>
-            <member optional="true"><type>VkAccessFlags</type>          <name>srcAccessMask</name><comment>Memory accesses from the source of the dependency to synchronize</comment></member>
-            <member optional="true"><type>VkAccessFlags</type>          <name>dstAccessMask</name><comment>Memory accesses from the destination of the dependency to synchronize</comment></member>
+            <member noautovalidity="true"><type>VkAccessFlags</type>          <name>srcAccessMask</name><comment>Memory accesses from the source of the dependency to synchronize</comment></member>
+            <member noautovalidity="true"><type>VkAccessFlags</type>          <name>dstAccessMask</name><comment>Memory accesses from the destination of the dependency to synchronize</comment></member>
             <member><type>uint32_t</type>               <name>srcQueueFamilyIndex</name><comment>Queue family to transition ownership from</comment></member>
             <member><type>uint32_t</type>               <name>dstQueueFamilyIndex</name><comment>Queue family to transition ownership to</comment></member>
             <member><type>VkBuffer</type>               <name>buffer</name><comment>Buffer to sync</comment></member>
@@ -900,8 +906,8 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkImageMemoryBarrier">
             <member values="VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*            <name>pNext</name></member>
-            <member optional="true"><type>VkAccessFlags</type>          <name>srcAccessMask</name><comment>Memory accesses from the source of the dependency to synchronize</comment></member>
-            <member optional="true"><type>VkAccessFlags</type>          <name>dstAccessMask</name><comment>Memory accesses from the destination of the dependency to synchronize</comment></member>
+            <member noautovalidity="true"><type>VkAccessFlags</type>          <name>srcAccessMask</name><comment>Memory accesses from the source of the dependency to synchronize</comment></member>
+            <member noautovalidity="true"><type>VkAccessFlags</type>          <name>dstAccessMask</name><comment>Memory accesses from the destination of the dependency to synchronize</comment></member>
             <member><type>VkImageLayout</type>          <name>oldLayout</name><comment>Current layout of the image</comment></member>
             <member><type>VkImageLayout</type>          <name>newLayout</name><comment>New layout to transition the image to</comment></member>
             <member><type>uint32_t</type>               <name>srcQueueFamilyIndex</name><comment>Queue family to transition ownership from</comment></member>
@@ -1364,7 +1370,7 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkRenderPassCreateInfo">
             <member values="VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*            <name>pNext</name></member>
-            <member optional="true" noautovalidity="true"><type>VkRenderPassCreateFlags</type>    <name>flags</name></member>
+            <member optional="true"><type>VkRenderPassCreateFlags</type> <name>flags</name></member>
             <member optional="true"><type>uint32_t</type>   <name>attachmentCount</name></member>
             <member len="attachmentCount">const <type>VkAttachmentDescription</type>* <name>pAttachments</name></member>
             <member><type>uint32_t</type>               <name>subpassCount</name></member>
@@ -3314,7 +3320,7 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkRenderPassCreateInfo2KHR">
             <member values="VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                                              <name>pNext</name></member>
-            <member optional="true" noautovalidity="true"><type>VkRenderPassCreateFlags</type> <name>flags</name></member>
+            <member optional="true"><type>VkRenderPassCreateFlags</type>                  <name>flags</name></member>
             <member optional="true"><type>uint32_t</type>                                 <name>attachmentCount</name></member>
             <member len="attachmentCount">const <type>VkAttachmentDescription2KHR</type>* <name>pAttachments</name></member>
             <member><type>uint32_t</type>                                                 <name>subpassCount</name></member>
@@ -3918,8 +3924,8 @@ typedef void <name>CAMetalLayer</name>;
         </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 -->
+            <member><type>void</type>*                  <name>pNext</name></member>
+            <member><type>VkBool32</type>               <name>textureCompressionASTC_HDR</name></member>
         </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>
@@ -3987,6 +3993,58 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>void</type>*            <name>pNext</name></member>
             <member><type>VkBool32</type>         <name>fullScreenExclusiveSupported</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDevicePerformanceQueryFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member noautovalidity="true"><type>void</type>*      <name>pNext</name></member>
+            <member><type>VkBool32</type>                         <name>performanceCounterQueryPools</name><comment>performance counters supported in query pools</comment></member>
+            <member><type>VkBool32</type>                         <name>performanceCounterMultipleQueryPools</name><comment>performance counters from multiple query pools can be accessed in the same primary command buffer</comment></member>        </type>
+        <type category="struct" name="VkPhysicalDevicePerformanceQueryPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
+             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+             <member><type>void</type>* <name>pNext</name></member>
+             <member noautovalidity="true"><type>VkBool32</type> <name>allowCommandBufferQueryCopies</name><comment>Flag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults</comment></member>
+        </type>
+        <type category="struct" name="VkPerformanceCounterKHR" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                             <name>pNext</name></member> <!-- Pointer to next structure -->
+            <member><type>VkPerformanceCounterUnitKHR</type>        <name>unit</name></member>
+            <member><type>VkPerformanceCounterScopeKHR</type>       <name>scope</name></member>
+            <member><type>VkPerformanceCounterStorageKHR</type>     <name>storage</name></member>
+            <member><type>uint8_t</type> <name>uuid</name>[<enum>VK_UUID_SIZE</enum>]</member>
+        </type>
+        <type category="struct" name="VkPerformanceCounterDescriptionKHR" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                             <name>pNext</name></member> <!-- Pointer to next structure -->
+            <member optional="true"><type>VkPerformanceCounterDescriptionFlagsKHR</type> <name>flags</name></member>
+            <member><type>char</type>                                    <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+            <member><type>char</type>                                    <name>category</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+            <member><type>char</type>                                    <name>description</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
+        </type>
+        <type category="struct" name="VkQueryPoolPerformanceCreateInfoKHR" structextends="VkQueryPoolCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                             <name>pNext</name></member> <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                                <name>queueFamilyIndex</name></member>
+            <member><type>uint32_t</type>                                <name>counterIndexCount</name></member>
+            <member len="counterIndexCount">const <type>uint32_t</type>* <name>pCounterIndices</name></member>
+        </type>
+        <type category="union" name="VkPerformanceCounterResultKHR" comment="// Union of all the possible return types a counter result could return">
+            <member><type>int32_t</type>  <name>int32</name></member>
+            <member><type>int64_t</type>  <name>int64</name></member>
+            <member><type>uint32_t</type> <name>uint32</name></member>
+            <member><type>uint64_t</type> <name>uint64</name></member>
+            <member><type>float</type>    <name>float32</name></member>
+            <member><type>double</type>   <name>float64</name></member>
+        </type>
+        <type category="struct" name="VkAcquireProfilingLockInfoKHR">
+            <member values="VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*            <name>pNext</name></member>
+            <member optional="true"><type>VkAcquireProfilingLockFlagsKHR</type> <name>flags</name><comment>Acquire profiling lock flags</comment></member>
+            <member><type>uint64_t</type> <name>timeout</name></member>
+        </type>
+        <type category="struct" name="VkPerformanceQuerySubmitInfoKHR" structextends="VkSubmitInfo">
+            <member values="VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*         <name>pNext</name></member>
+            <member><type>uint32_t</type>            <name>counterPassIndex</name><comment>Index for which counter pass to submit</comment></member>
+        </type>
         <type category="struct" name="VkHeadlessSurfaceCreateInfoEXT">
             <member values="VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*            <name>pNext</name></member>
@@ -5475,6 +5533,38 @@ 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="VkPerformanceCounterScopeKHR" type="enum">
+        <enum value="0"     name="VK_QUERY_SCOPE_COMMAND_BUFFER_KHR"/>
+        <enum value="1"     name="VK_QUERY_SCOPE_RENDER_PASS_KHR"/>
+        <enum value="2"     name="VK_QUERY_SCOPE_COMMAND_KHR"/>
+    </enums>
+    <enums name="VkPerformanceCounterUnitKHR" type="enum">
+        <enum value="0"     name="VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR"/>
+        <enum value="1"     name="VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR"/>
+        <enum value="2"     name="VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR"/>
+        <enum value="3"     name="VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR"/>
+        <enum value="4"     name="VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR"/>
+        <enum value="5"     name="VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR"/>
+        <enum value="6"     name="VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR"/>
+        <enum value="7"     name="VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR"/>
+        <enum value="8"     name="VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR"/>
+        <enum value="9"     name="VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR"/>
+        <enum value="10"    name="VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR"/>
+    </enums>
+    <enums name="VkPerformanceCounterStorageKHR" type="enum">
+        <enum value="0"     name="VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR"/>
+        <enum value="1"     name="VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR"/>
+        <enum value="2"     name="VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR"/>
+        <enum value="3"     name="VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR"/>
+        <enum value="4"     name="VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR"/>
+        <enum value="5"     name="VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR"/>
+    </enums>
+    <enums name="VkPerformanceCounterDescriptionFlagBitsKHR" type="bitmask">
+        <enum bitpos="0"     name="VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR"/>
+        <enum bitpos="1"     name="VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR"/>
+    </enums>
+    <enums name="VkAcquireProfilingLockFlagBitsKHR" type="bitmask">
+    </enums>
     <enums name="VkShaderCorePropertiesFlagBitsAMD" type="bitmask">
     </enums>
     <enums name="VkPerformanceConfigurationTypeINTEL" type="enum">
@@ -6025,7 +6115,7 @@ typedef void <name>CAMetalLayer</name>;
             <param optional="true" externsync="true"><type>VkDescriptorPool</type> <name>descriptorPool</name></param>
             <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
         </command>
-        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+        <command successcodes="VK_SUCCESS">
             <proto><type>VkResult</type> <name>vkResetDescriptorPool</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param externsync="true"><type>VkDescriptorPool</type> <name>descriptorPool</name></param>
@@ -6040,7 +6130,7 @@ typedef void <name>CAMetalLayer</name>;
             <param externsync="pAllocateInfo::descriptorPool">const <type>VkDescriptorSetAllocateInfo</type>* <name>pAllocateInfo</name></param>
             <param len="pAllocateInfo::descriptorSetCount"><type>VkDescriptorSet</type>* <name>pDescriptorSets</name></param>
         </command>
-        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+        <command successcodes="VK_SUCCESS">
             <proto><type>VkResult</type> <name>vkFreeDescriptorSets</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param externsync="true"><type>VkDescriptorPool</type> <name>descriptorPool</name></param>
@@ -7732,17 +7822,6 @@ typedef void <name>CAMetalLayer</name>;
             <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
             <param len="createInfoCount"><type>VkPipeline</type>* <name>pPipelines</name></param>
         </command>
-        <command successcodes="VK_SUCCESS">
-            <proto><type>VkResult</type> <name>vkGetImageDrmFormatModifierPropertiesEXT</name></proto>
-            <param><type>VkDevice</type> <name>device</name></param>
-            <param><type>VkImage</type> <name>image</name></param>
-            <param><type>VkImageDrmFormatModifierPropertiesEXT</type>* <name>pProperties</name></param>
-        </command>
-        <command>
-            <proto><type>VkDeviceAddress</type> <name>vkGetBufferDeviceAddressEXT</name></proto>
-            <param><type>VkDevice</type> <name>device</name></param>
-            <param>const <type>VkBufferDeviceAddressInfoEXT</type>* <name>pInfo</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>vkGetPhysicalDeviceCooperativeMatrixPropertiesNV</name></proto>
             <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
@@ -7777,6 +7856,40 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>VkDevice</type> <name>device</name></param>
             <param><type>VkSwapchainKHR</type> <name>swapchain</name></param>
         </command>
+        <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
+            <proto><type>VkResult</type> <name>vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param><type>uint32_t</type> <name>queueFamilyIndex</name></param>
+            <param optional="false,true"><type>uint32_t</type>* <name>pCounterCount</name></param>
+            <param optional="true" len="pCounterCount"><type>VkPerformanceCounterKHR</type>* <name>pCounters</name></param>
+            <param optional="true" len="pCounterCount"><type>VkPerformanceCounterDescriptionKHR</type>* <name>pCounterDescriptions</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param>const <type>VkQueryPoolPerformanceCreateInfoKHR</type>* <name>pPerformanceQueryCreateInfo</name></param>
+            <param><type>uint32_t</type>* <name>pNumPasses</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_TIMEOUT">
+            <proto><type>VkResult</type> <name>vkAcquireProfilingLockKHR</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkAcquireProfilingLockInfoKHR</type>* <name>pInfo</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkReleaseProfilingLockKHR</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS">
+            <proto><type>VkResult</type> <name>vkGetImageDrmFormatModifierPropertiesEXT</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkImage</type> <name>image</name></param>
+            <param><type>VkImageDrmFormatModifierPropertiesEXT</type>* <name>pProperties</name></param>
+        </command>
+        <command>
+            <proto><type>VkDeviceAddress</type> <name>vkGetBufferDeviceAddressEXT</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkBufferDeviceAddressInfoEXT</type>* <name>pInfo</name></param>
+        </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
             <proto><type>VkResult</type> <name>vkCreateHeadlessSurfaceEXT</name></proto>
             <param><type>VkInstance</type> <name>instance</name></param>
@@ -8079,7 +8192,7 @@ typedef void <name>CAMetalLayer</name>;
             <command name="vkCmdEndRenderPass"/>
             <command name="vkCmdExecuteCommands"/>
         </require>
-        <require comment="Types not directly used by the API. Include e.g. structs that are not parameter types of commands, but still defined by the API.">
+        <require comment="These types are part of the API and should always be defined, even when no enabled features require them.">
             <type name="VkBufferMemoryBarrier"/>
             <type name="VkDispatchIndirectCommand"/>
             <type name="VkDrawIndexedIndirectCommand"/>
@@ -8147,7 +8260,8 @@ typedef void <name>CAMetalLayer</name>;
             <command name="vkCmdSetDeviceMask"/>
             <command name="vkCmdDispatchBase"/>
             <enum bitpos="3"  extends="VkPipelineCreateFlagBits"                name="VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"/>
-            <enum bitpos="4"  extends="VkPipelineCreateFlagBits"                name="VK_PIPELINE_CREATE_DISPATCH_BASE"/>
+            <enum bitpos="4"  extends="VkPipelineCreateFlagBits"                name="VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"/>
+            <enum extends="VkPipelineCreateFlagBits"                            name="VK_PIPELINE_CREATE_DISPATCH_BASE" alias="VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"/>
             <enum bitpos="2"  extends="VkDependencyFlagBits"                    name="VK_DEPENDENCY_DEVICE_GROUP_BIT" comment="Dependency is across devices"/>
         </require>
         <require comment="Promoted from VK_KHR_device_group + VK_KHR_bind_memory2">
@@ -9821,10 +9935,37 @@ typedef void <name>CAMetalLayer</name>;
                 <command name="vkGetFenceFdKHR"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_117" number="117" author="KHR" contact="Kenneth Benzie @kbenzie" supported="disabled">
-            <require>
-                <enum value="0"                                             name="VK_KHR_EXTENSION_117_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_117&quot;"              name="VK_KHR_EXTENSION_117_EXTENSION_NAME"/>
+        <extension name="VK_KHR_performance_query" number="117" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Alon Or-bach @alonorbach" supported="vulkan">
+            <require>
+                <enum value="1"                                    name="VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_performance_query&quot;" name="VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkQueryType"             name="VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR"/>
+                <enum offset="0" extends="VkStructureType"         name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"/>
+                <enum offset="1" extends="VkStructureType"         name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"/>
+                <enum offset="2" extends="VkStructureType"         name="VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"/>
+                <enum offset="3" extends="VkStructureType"         name="VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"/>
+                <enum offset="4" extends="VkStructureType"         name="VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"/>
+                <enum offset="5" extends="VkStructureType"         name="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"/>
+                <enum offset="6" extends="VkStructureType"         name="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"/>
+                <type name="VkPhysicalDevicePerformanceQueryFeaturesKHR"/>
+                <type name="VkPhysicalDevicePerformanceQueryPropertiesKHR"/>
+                <type name="VkPerformanceCounterKHR"/>
+                <type name="VkPerformanceCounterDescriptionKHR"/>
+                <type name="VkPerformanceCounterDescriptionFlagsKHR"/>
+                <type name="VkPerformanceCounterDescriptionFlagBitsKHR"/>
+                <type name="VkQueryPoolPerformanceCreateInfoKHR"/>
+                <type name="VkPerformanceCounterScopeKHR"/>
+                <type name="VkPerformanceCounterStorageKHR"/>
+                <type name="VkPerformanceCounterUnitKHR"/>
+                <type name="VkPerformanceCounterResultKHR"/>
+                <type name="VkAcquireProfilingLockInfoKHR"/>
+                <type name="VkAcquireProfilingLockFlagsKHR"/>
+                <type name="VkAcquireProfilingLockFlagBitsKHR"/>
+                <type name="VkPerformanceQuerySubmitInfoKHR"/>
+                <command name="vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"/>
+                <command name="vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"/>
+                <command name="vkAcquireProfilingLockKHR"/>
+                <command name="vkReleaseProfilingLockKHR"/>
             </require>
         </extension>
         <extension name="VK_KHR_maintenance2" number="118" type="device" author="KHR" contact="Michael Worcester @michaelworcester" supported="vulkan" promotedto="VK_VERSION_1_1">
@@ -10225,6 +10366,7 @@ typedef void <name>CAMetalLayer</name>;
             <require>
                 <enum value="0"                                             name="VK_NV_EXTENSION_151_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_extension_151&quot;"               name="VK_NV_EXTENSION_151_EXTENSION_NAME"/>
+                <enum bitpos="11" extends="VkPipelineCreateFlagBits"        name="VK_PIPELINE_CREATE_EXTENSION_151_BIT_NV"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_152" number="152" author="NV" contact="Jeff Bolz @jeffbolznv" supported="disabled">
@@ -11388,7 +11530,7 @@ typedef void <name>CAMetalLayer</name>;
                 <command name="vkGetDeviceGroupSurfacePresentModes2EXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_headless_surface" number="257" type="instance" requires="VK_KHR_surface" author="EXT" contact="Ray Smith @raysmith-arm" supported="vulkan">
+        <extension name="VK_EXT_headless_surface" number="257" type="instance" requires="VK_KHR_surface" author="EXT" contact="Lisa Wu @chengtianww" supported="vulkan">
             <require>
                 <enum value="1"                                                 name="VK_EXT_HEADLESS_SURFACE_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_headless_surface&quot;"               name="VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME"/>
@@ -11641,6 +11783,8 @@ typedef void <name>CAMetalLayer</name>;
             <require>
                 <enum value="0"                                             name="VK_NV_EXTENSION_291_SPEC_VERSION"/>
                 <enum value="&quot;VK_NV_extension_291&quot;"               name="VK_NV_EXTENSION_291_EXTENSION_NAME"/>
+                <enum bitpos="12"  extends="VkPipelineCreateFlagBits"       name="VK_PIPELINE_CREATE_EXTENSION_291_BIT0_NV"/>
+                <enum bitpos="13"  extends="VkPipelineCreateFlagBits"       name="VK_PIPELINE_CREATE_EXTENSION_291_BIT1_NV"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_292" number="292" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
@@ -11680,5 +11824,15 @@ typedef void <name>CAMetalLayer</name>;
                 <enum bitpos="3" extends="VkPipelineShaderStageCreateFlagBits"  name="VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR"/>
             </require>
         </extension>
+        <extension name="VK_EXT_extension_298" number="298" author="AMD" contact="Gregory Grebe @grgrebe-amd" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_EXT_EXTENSION_298_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_298&quot;"          name="VK_EXT_EXTENSION_298_EXTENSION_NAME"/>
+                <enum bitpos="8"  extends="VkPipelineCreateFlagBits"    name="VK_PIPELINE_CREATE_RESERVED_8_BIT_EXT"/>
+                <enum bitpos="9"  extends="VkPipelineCreateFlagBits"    name="VK_PIPELINE_CREATE_RESERVED_9_BIT_EXT"/>
+                <enum bitpos="10" extends="VkPipelineCreateFlagBits"    name="VK_PIPELINE_CREATE_RESERVED_10_BIT_EXT"/>
+                <enum extends="VkResult" offset="0"                     name="VK_RESULT_EXT_298_RESERVED_VALUE_0_EXT"/>
+            </require>
+        </extension>
     </extensions>
 </registry>