Update for Vulkan-Docs 1.2.153
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 45f781f..b8e35f1 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -89,7 +89,7 @@
 #endif
 
 
-static_assert( VK_HEADER_VERSION ==  152 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION ==  153 , "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
@@ -13937,8 +13937,6 @@
     Result                        result;
     UniqueHandle<Type, Dispatch>  value;
 
-    operator std::tuple<Result&, UniqueHandle<Type, Dispatch>&>() VULKAN_HPP_NOEXCEPT { return std::tuple<Result&, UniqueHandle<Type, Dispatch>&>(result, value); }
-
 #  if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
     VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
     operator UniqueHandle<Type, Dispatch>& () & VULKAN_HPP_NOEXCEPT
@@ -14138,6 +14136,8 @@
     : minX( minX_ ), minY( minY_ ), minZ( minZ_ ), maxX( maxX_ ), maxY( maxY_ ), maxZ( maxZ_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AabbPositionsKHR( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AabbPositionsKHR( VkAabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -14150,6 +14150,12 @@
       return *this;
     }
 
+    AabbPositionsKHR & operator=( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AabbPositionsKHR ) );
+      return *this;
+    }
+
     AabbPositionsKHR & setMinX( float minX_ ) VULKAN_HPP_NOEXCEPT
     {
       minX = minX_;
@@ -14398,6 +14404,8 @@
     : vertexFormat( vertexFormat_ ), vertexData( vertexData_ ), vertexStride( vertexStride_ ), indexType( indexType_ ), indexData( indexData_ ), transformData( transformData_ )
     {}
 
+    AccelerationStructureGeometryTrianglesDataKHR( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureGeometryTrianglesDataKHR( VkAccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -14412,14 +14420,7 @@
 
     AccelerationStructureGeometryTrianglesDataKHR & operator=( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    vertexFormat = rhs.vertexFormat;
-    vertexData = rhs.vertexData;
-    vertexStride = rhs.vertexStride;
-    indexType = rhs.indexType;
-    indexData = rhs.indexData;
-    transformData = rhs.transformData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureGeometryTrianglesDataKHR ) );
       return *this;
     }
 
@@ -14511,6 +14512,8 @@
     : data( data_ ), stride( stride_ )
     {}
 
+    AccelerationStructureGeometryAabbsDataKHR( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureGeometryAabbsDataKHR( VkAccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -14525,10 +14528,7 @@
 
     AccelerationStructureGeometryAabbsDataKHR & operator=( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    data = rhs.data;
-    stride = rhs.stride;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureGeometryAabbsDataKHR ) );
       return *this;
     }
 
@@ -14592,6 +14592,8 @@
     : arrayOfPointers( arrayOfPointers_ ), data( data_ )
     {}
 
+    AccelerationStructureGeometryInstancesDataKHR( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureGeometryInstancesDataKHR( VkAccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -14606,10 +14608,7 @@
 
     AccelerationStructureGeometryInstancesDataKHR & operator=( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    arrayOfPointers = rhs.arrayOfPointers;
-    data = rhs.data;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureGeometryInstancesDataKHR ) );
       return *this;
     }
 
@@ -14739,6 +14738,8 @@
     : geometryType( geometryType_ ), geometry( geometry_ ), flags( flags_ )
     {}
 
+    AccelerationStructureGeometryKHR( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureGeometryKHR( VkAccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -14753,11 +14754,7 @@
 
     AccelerationStructureGeometryKHR & operator=( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    geometryType = rhs.geometryType;
-    geometry = rhs.geometry;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureGeometryKHR ) );
       return *this;
     }
 
@@ -14882,6 +14879,8 @@
     : type( type_ ), flags( flags_ ), update( update_ ), srcAccelerationStructure( srcAccelerationStructure_ ), dstAccelerationStructure( dstAccelerationStructure_ ), geometryArrayOfPointers( geometryArrayOfPointers_ ), geometryCount( geometryCount_ ), ppGeometries( ppGeometries_ ), scratchData( scratchData_ )
     {}
 
+    AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureBuildGeometryInfoKHR( VkAccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -14896,17 +14895,7 @@
 
     AccelerationStructureBuildGeometryInfoKHR & operator=( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    type = rhs.type;
-    flags = rhs.flags;
-    update = rhs.update;
-    srcAccelerationStructure = rhs.srcAccelerationStructure;
-    dstAccelerationStructure = rhs.dstAccelerationStructure;
-    geometryArrayOfPointers = rhs.geometryArrayOfPointers;
-    geometryCount = rhs.geometryCount;
-    ppGeometries = rhs.ppGeometries;
-    scratchData = rhs.scratchData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureBuildGeometryInfoKHR ) );
       return *this;
     }
 
@@ -15018,6 +15007,8 @@
     : primitiveCount( primitiveCount_ ), primitiveOffset( primitiveOffset_ ), firstVertex( firstVertex_ ), transformOffset( transformOffset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureBuildOffsetInfoKHR( AccelerationStructureBuildOffsetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureBuildOffsetInfoKHR( VkAccelerationStructureBuildOffsetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -15030,6 +15021,12 @@
       return *this;
     }
 
+    AccelerationStructureBuildOffsetInfoKHR & operator=( AccelerationStructureBuildOffsetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureBuildOffsetInfoKHR ) );
+      return *this;
+    }
+
     AccelerationStructureBuildOffsetInfoKHR & setPrimitiveCount( uint32_t primitiveCount_ ) VULKAN_HPP_NOEXCEPT
     {
       primitiveCount = primitiveCount_;
@@ -15107,6 +15104,8 @@
     : geometryType( geometryType_ ), maxPrimitiveCount( maxPrimitiveCount_ ), indexType( indexType_ ), maxVertexCount( maxVertexCount_ ), vertexFormat( vertexFormat_ ), allowsTransforms( allowsTransforms_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateGeometryTypeInfoKHR( AccelerationStructureCreateGeometryTypeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureCreateGeometryTypeInfoKHR( VkAccelerationStructureCreateGeometryTypeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -15121,14 +15120,7 @@
 
     AccelerationStructureCreateGeometryTypeInfoKHR & operator=( AccelerationStructureCreateGeometryTypeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    geometryType = rhs.geometryType;
-    maxPrimitiveCount = rhs.maxPrimitiveCount;
-    indexType = rhs.indexType;
-    maxVertexCount = rhs.maxVertexCount;
-    vertexFormat = rhs.vertexFormat;
-    allowsTransforms = rhs.allowsTransforms;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureCreateGeometryTypeInfoKHR ) );
       return *this;
     }
 
@@ -15241,6 +15233,8 @@
     : compactedSize( compactedSize_ ), type( type_ ), flags( flags_ ), maxGeometryCount( maxGeometryCount_ ), pGeometryInfos( pGeometryInfos_ ), deviceAddress( deviceAddress_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureCreateInfoKHR( VkAccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -15261,14 +15255,7 @@
 
     AccelerationStructureCreateInfoKHR & operator=( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    compactedSize = rhs.compactedSize;
-    type = rhs.type;
-    flags = rhs.flags;
-    maxGeometryCount = rhs.maxGeometryCount;
-    pGeometryInfos = rhs.pGeometryInfos;
-    deviceAddress = rhs.deviceAddress;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureCreateInfoKHR ) );
       return *this;
     }
 
@@ -15489,6 +15476,8 @@
     : vertexData( vertexData_ ), vertexOffset( vertexOffset_ ), vertexCount( vertexCount_ ), vertexStride( vertexStride_ ), vertexFormat( vertexFormat_ ), indexData( indexData_ ), indexOffset( indexOffset_ ), indexCount( indexCount_ ), indexType( indexType_ ), transformData( transformData_ ), transformOffset( transformOffset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -15503,19 +15492,7 @@
 
     GeometryTrianglesNV & operator=( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    vertexData = rhs.vertexData;
-    vertexOffset = rhs.vertexOffset;
-    vertexCount = rhs.vertexCount;
-    vertexStride = rhs.vertexStride;
-    vertexFormat = rhs.vertexFormat;
-    indexData = rhs.indexData;
-    indexOffset = rhs.indexOffset;
-    indexCount = rhs.indexCount;
-    indexType = rhs.indexType;
-    transformData = rhs.transformData;
-    transformOffset = rhs.transformOffset;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GeometryTrianglesNV ) );
       return *this;
     }
 
@@ -15666,6 +15643,8 @@
     : aabbData( aabbData_ ), numAABBs( numAABBs_ ), stride( stride_ ), offset( offset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR GeometryAABBNV( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -15680,12 +15659,7 @@
 
     GeometryAABBNV & operator=( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    aabbData = rhs.aabbData;
-    numAABBs = rhs.numAABBs;
-    stride = rhs.stride;
-    offset = rhs.offset;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GeometryAABBNV ) );
       return *this;
     }
 
@@ -15779,6 +15753,8 @@
     : triangles( triangles_ ), aabbs( aabbs_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR GeometryDataNV( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -15791,6 +15767,12 @@
       return *this;
     }
 
+    GeometryDataNV & operator=( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GeometryDataNV ) );
+      return *this;
+    }
+
     GeometryDataNV & setTriangles( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & triangles_ ) VULKAN_HPP_NOEXCEPT
     {
       triangles = triangles_;
@@ -15850,6 +15832,8 @@
     : geometryType( geometryType_ ), geometry( geometry_ ), flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR GeometryNV( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -15864,11 +15848,7 @@
 
     GeometryNV & operator=( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    geometryType = rhs.geometryType;
-    geometry = rhs.geometry;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GeometryNV ) );
       return *this;
     }
 
@@ -15955,6 +15935,8 @@
     : type( type_ ), flags( flags_ ), instanceCount( instanceCount_ ), geometryCount( geometryCount_ ), pGeometries( pGeometries_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -15975,13 +15957,7 @@
 
     AccelerationStructureInfoNV & operator=( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    type = rhs.type;
-    flags = rhs.flags;
-    instanceCount = rhs.instanceCount;
-    geometryCount = rhs.geometryCount;
-    pGeometries = rhs.pGeometries;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureInfoNV ) );
       return *this;
     }
 
@@ -16093,6 +16069,8 @@
     : compactedSize( compactedSize_ ), info( info_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -16107,10 +16085,7 @@
 
     AccelerationStructureCreateInfoNV & operator=( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    compactedSize = rhs.compactedSize;
-    info = rhs.info;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
       return *this;
     }
 
@@ -16190,6 +16165,8 @@
     : accelerationStructure( accelerationStructure_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureDeviceAddressInfoKHR( VkAccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -16204,9 +16181,7 @@
 
     AccelerationStructureDeviceAddressInfoKHR & operator=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    accelerationStructure = rhs.accelerationStructure;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureDeviceAddressInfoKHR ) );
       return *this;
     }
 
@@ -16277,6 +16252,8 @@
     : matrix( matrix_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     TransformMatrixKHR( VkTransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -16289,6 +16266,12 @@
       return *this;
     }
 
+    TransformMatrixKHR & operator=( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( TransformMatrixKHR ) );
+      return *this;
+    }
+
     TransformMatrixKHR & setMatrix( std::array<std::array<float,4>,3> matrix_ ) VULKAN_HPP_NOEXCEPT
     {
       matrix = matrix_;
@@ -16340,6 +16323,8 @@
     : transform( transform_ ), instanceCustomIndex( instanceCustomIndex_ ), mask( mask_ ), instanceShaderBindingTableRecordOffset( instanceShaderBindingTableRecordOffset_ ), flags( flags_ ), accelerationStructureReference( accelerationStructureReference_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureInstanceKHR( VkAccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -16352,6 +16337,12 @@
       return *this;
     }
 
+    AccelerationStructureInstanceKHR & operator=( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureInstanceKHR ) );
+      return *this;
+    }
+
     AccelerationStructureInstanceKHR & setTransform( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transform_ ) VULKAN_HPP_NOEXCEPT
     {
       transform = transform_;
@@ -16445,6 +16436,8 @@
     : type( type_ ), buildType( buildType_ ), accelerationStructure( accelerationStructure_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoKHR( AccelerationStructureMemoryRequirementsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureMemoryRequirementsInfoKHR( VkAccelerationStructureMemoryRequirementsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -16459,11 +16452,7 @@
 
     AccelerationStructureMemoryRequirementsInfoKHR & operator=( AccelerationStructureMemoryRequirementsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    type = rhs.type;
-    buildType = rhs.buildType;
-    accelerationStructure = rhs.accelerationStructure;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoKHR ) );
       return *this;
     }
 
@@ -16551,6 +16540,8 @@
     : type( type_ ), accelerationStructure( accelerationStructure_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -16565,10 +16556,7 @@
 
     AccelerationStructureMemoryRequirementsInfoNV & operator=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    type = rhs.type;
-    accelerationStructure = rhs.accelerationStructure;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
       return *this;
     }
 
@@ -16648,6 +16636,8 @@
     : versionData( versionData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AccelerationStructureVersionKHR( AccelerationStructureVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AccelerationStructureVersionKHR( VkAccelerationStructureVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -16662,9 +16652,7 @@
 
     AccelerationStructureVersionKHR & operator=( AccelerationStructureVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    versionData = rhs.versionData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AccelerationStructureVersionKHR ) );
       return *this;
     }
 
@@ -17036,6 +17024,8 @@
     : swapchain( swapchain_ ), timeout( timeout_ ), semaphore( semaphore_ ), fence( fence_ ), deviceMask( deviceMask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17050,13 +17040,7 @@
 
     AcquireNextImageInfoKHR & operator=( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    swapchain = rhs.swapchain;
-    timeout = rhs.timeout;
-    semaphore = rhs.semaphore;
-    fence = rhs.fence;
-    deviceMask = rhs.deviceMask;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AcquireNextImageInfoKHR ) );
       return *this;
     }
 
@@ -17159,6 +17143,8 @@
     : flags( flags_ ), timeout( timeout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AcquireProfilingLockInfoKHR( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17173,10 +17159,7 @@
 
     AcquireProfilingLockInfoKHR & operator=( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    timeout = rhs.timeout;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AcquireProfilingLockInfoKHR ) );
       return *this;
     }
 
@@ -17254,6 +17237,8 @@
     : pUserData( pUserData_ ), pfnAllocation( pfnAllocation_ ), pfnReallocation( pfnReallocation_ ), pfnFree( pfnFree_ ), pfnInternalAllocation( pfnInternalAllocation_ ), pfnInternalFree( pfnInternalFree_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AllocationCallbacks( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17266,6 +17251,12 @@
       return *this;
     }
 
+    AllocationCallbacks & operator=( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AllocationCallbacks ) );
+      return *this;
+    }
+
     AllocationCallbacks & setPUserData( void* pUserData_ ) VULKAN_HPP_NOEXCEPT
     {
       pUserData = pUserData_;
@@ -17356,6 +17347,8 @@
     : r( r_ ), g( g_ ), b( b_ ), a( a_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ComponentMapping( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17368,6 +17361,12 @@
       return *this;
     }
 
+    ComponentMapping & operator=( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ComponentMapping ) );
+      return *this;
+    }
+
     ComponentMapping & setR( VULKAN_HPP_NAMESPACE::ComponentSwizzle r_ ) VULKAN_HPP_NOEXCEPT
     {
       r = r_;
@@ -17444,6 +17443,8 @@
     : format( format_ ), externalFormat( externalFormat_ ), formatFeatures( formatFeatures_ ), samplerYcbcrConversionComponents( samplerYcbcrConversionComponents_ ), suggestedYcbcrModel( suggestedYcbcrModel_ ), suggestedYcbcrRange( suggestedYcbcrRange_ ), suggestedXChromaOffset( suggestedXChromaOffset_ ), suggestedYChromaOffset( suggestedYChromaOffset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatPropertiesANDROID( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17458,16 +17459,7 @@
 
     AndroidHardwareBufferFormatPropertiesANDROID & operator=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    format = rhs.format;
-    externalFormat = rhs.externalFormat;
-    formatFeatures = rhs.formatFeatures;
-    samplerYcbcrConversionComponents = rhs.samplerYcbcrConversionComponents;
-    suggestedYcbcrModel = rhs.suggestedYcbcrModel;
-    suggestedYcbcrRange = rhs.suggestedYcbcrRange;
-    suggestedXChromaOffset = rhs.suggestedXChromaOffset;
-    suggestedYChromaOffset = rhs.suggestedYChromaOffset;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) );
       return *this;
     }
 
@@ -17542,6 +17534,8 @@
     : allocationSize( allocationSize_ ), memoryTypeBits( memoryTypeBits_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AndroidHardwareBufferPropertiesANDROID( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17556,10 +17550,7 @@
 
     AndroidHardwareBufferPropertiesANDROID & operator=( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    allocationSize = rhs.allocationSize;
-    memoryTypeBits = rhs.memoryTypeBits;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AndroidHardwareBufferPropertiesANDROID ) );
       return *this;
     }
 
@@ -17622,6 +17613,8 @@
     : androidHardwareBufferUsage( androidHardwareBufferUsage_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17636,9 +17629,7 @@
 
     AndroidHardwareBufferUsageANDROID & operator=( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    androidHardwareBufferUsage = rhs.androidHardwareBufferUsage;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AndroidHardwareBufferUsageANDROID ) );
       return *this;
     }
 
@@ -17699,6 +17690,8 @@
     : flags( flags_ ), window( window_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17713,10 +17706,7 @@
 
     AndroidSurfaceCreateInfoKHR & operator=( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    window = rhs.window;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
       return *this;
     }
 
@@ -17796,6 +17786,8 @@
     : pApplicationName( pApplicationName_ ), applicationVersion( applicationVersion_ ), pEngineName( pEngineName_ ), engineVersion( engineVersion_ ), apiVersion( apiVersion_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ApplicationInfo( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17810,13 +17802,7 @@
 
     ApplicationInfo & operator=( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pApplicationName = rhs.pApplicationName;
-    applicationVersion = rhs.applicationVersion;
-    pEngineName = rhs.pEngineName;
-    engineVersion = rhs.engineVersion;
-    apiVersion = rhs.apiVersion;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ApplicationInfo ) );
       return *this;
     }
 
@@ -17918,6 +17904,8 @@
     : flags( flags_ ), format( format_ ), samples( samples_ ), loadOp( loadOp_ ), storeOp( storeOp_ ), stencilLoadOp( stencilLoadOp_ ), stencilStoreOp( stencilStoreOp_ ), initialLayout( initialLayout_ ), finalLayout( finalLayout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AttachmentDescription( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -17930,6 +17918,12 @@
       return *this;
     }
 
+    AttachmentDescription & operator=( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AttachmentDescription ) );
+      return *this;
+    }
+
     AttachmentDescription & setFlags( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags_ ) VULKAN_HPP_NOEXCEPT
     {
       flags = flags_;
@@ -18045,6 +18039,8 @@
     : flags( flags_ ), format( format_ ), samples( samples_ ), loadOp( loadOp_ ), storeOp( storeOp_ ), stencilLoadOp( stencilLoadOp_ ), stencilStoreOp( stencilStoreOp_ ), initialLayout( initialLayout_ ), finalLayout( finalLayout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AttachmentDescription2( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AttachmentDescription2( VkAttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18059,17 +18055,7 @@
 
     AttachmentDescription2 & operator=( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    format = rhs.format;
-    samples = rhs.samples;
-    loadOp = rhs.loadOp;
-    storeOp = rhs.storeOp;
-    stencilLoadOp = rhs.stencilLoadOp;
-    stencilStoreOp = rhs.stencilStoreOp;
-    initialLayout = rhs.initialLayout;
-    finalLayout = rhs.finalLayout;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AttachmentDescription2 ) );
       return *this;
     }
 
@@ -18205,6 +18191,8 @@
     : stencilInitialLayout( stencilInitialLayout_ ), stencilFinalLayout( stencilFinalLayout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AttachmentDescriptionStencilLayout( VkAttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18219,10 +18207,7 @@
 
     AttachmentDescriptionStencilLayout & operator=( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    stencilInitialLayout = rhs.stencilInitialLayout;
-    stencilFinalLayout = rhs.stencilFinalLayout;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AttachmentDescriptionStencilLayout ) );
       return *this;
     }
 
@@ -18301,6 +18286,8 @@
     : attachment( attachment_ ), layout( layout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AttachmentReference( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18313,6 +18300,12 @@
       return *this;
     }
 
+    AttachmentReference & operator=( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AttachmentReference ) );
+      return *this;
+    }
+
     AttachmentReference & setAttachment( uint32_t attachment_ ) VULKAN_HPP_NOEXCEPT
     {
       attachment = attachment_;
@@ -18372,6 +18365,8 @@
     : attachment( attachment_ ), layout( layout_ ), aspectMask( aspectMask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AttachmentReference2( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AttachmentReference2( VkAttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18386,11 +18381,7 @@
 
     AttachmentReference2 & operator=( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    attachment = rhs.attachment;
-    layout = rhs.layout;
-    aspectMask = rhs.aspectMask;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AttachmentReference2 ) );
       return *this;
     }
 
@@ -18478,6 +18469,8 @@
     : stencilLayout( stencilLayout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AttachmentReferenceStencilLayout( VkAttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18492,9 +18485,7 @@
 
     AttachmentReferenceStencilLayout & operator=( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    stencilLayout = rhs.stencilLayout;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AttachmentReferenceStencilLayout ) );
       return *this;
     }
 
@@ -18565,6 +18556,8 @@
     : width( width_ ), height( height_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Extent2D( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18577,6 +18570,12 @@
       return *this;
     }
 
+    Extent2D & operator=( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Extent2D ) );
+      return *this;
+    }
+
     Extent2D & setWidth( uint32_t width_ ) VULKAN_HPP_NOEXCEPT
     {
       width = width_;
@@ -18635,6 +18634,8 @@
     : x( x_ ), y( y_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SampleLocationEXT( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18647,6 +18648,12 @@
       return *this;
     }
 
+    SampleLocationEXT & operator=( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SampleLocationEXT ) );
+      return *this;
+    }
+
     SampleLocationEXT & setX( float x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -18706,6 +18713,8 @@
     : sampleLocationsPerPixel( sampleLocationsPerPixel_ ), sampleLocationGridSize( sampleLocationGridSize_ ), sampleLocationsCount( sampleLocationsCount_ ), pSampleLocations( pSampleLocations_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18726,12 +18735,7 @@
 
     SampleLocationsInfoEXT & operator=( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    sampleLocationsPerPixel = rhs.sampleLocationsPerPixel;
-    sampleLocationGridSize = rhs.sampleLocationGridSize;
-    sampleLocationsCount = rhs.sampleLocationsCount;
-    pSampleLocations = rhs.pSampleLocations;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SampleLocationsInfoEXT ) );
       return *this;
     }
 
@@ -18834,6 +18838,8 @@
     : attachmentIndex( attachmentIndex_ ), sampleLocationsInfo( sampleLocationsInfo_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18846,6 +18852,12 @@
       return *this;
     }
 
+    AttachmentSampleLocationsEXT & operator=( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+      return *this;
+    }
+
     AttachmentSampleLocationsEXT & setAttachmentIndex( uint32_t attachmentIndex_ ) VULKAN_HPP_NOEXCEPT
     {
       attachmentIndex = attachmentIndex_;
@@ -18904,6 +18916,8 @@
     : sType( sType_ )
     {}
 
+    BaseInStructure( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18916,6 +18930,12 @@
       return *this;
     }
 
+    BaseInStructure & operator=( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BaseInStructure ) );
+      return *this;
+    }
+
     BaseInStructure & setPNext( const struct VULKAN_HPP_NAMESPACE::BaseInStructure* pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -18968,6 +18988,8 @@
     : sType( sType_ )
     {}
 
+    BaseOutStructure( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -18980,6 +19002,12 @@
       return *this;
     }
 
+    BaseOutStructure & operator=( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BaseOutStructure ) );
+      return *this;
+    }
+
     BaseOutStructure & setPNext( struct VULKAN_HPP_NAMESPACE::BaseOutStructure* pNext_ ) VULKAN_HPP_NOEXCEPT
     {
       pNext = pNext_;
@@ -19133,6 +19161,8 @@
     : accelerationStructure( accelerationStructure_ ), memory( memory_ ), memoryOffset( memoryOffset_ ), deviceIndexCount( deviceIndexCount_ ), pDeviceIndices( pDeviceIndices_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoKHR( BindAccelerationStructureMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindAccelerationStructureMemoryInfoKHR( VkBindAccelerationStructureMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -19153,13 +19183,7 @@
 
     BindAccelerationStructureMemoryInfoKHR & operator=( BindAccelerationStructureMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    accelerationStructure = rhs.accelerationStructure;
-    memory = rhs.memory;
-    memoryOffset = rhs.memoryOffset;
-    deviceIndexCount = rhs.deviceIndexCount;
-    pDeviceIndices = rhs.pDeviceIndices;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindAccelerationStructureMemoryInfoKHR ) );
       return *this;
     }
 
@@ -19272,6 +19296,8 @@
     : deviceIndexCount( deviceIndexCount_ ), pDeviceIndices( pDeviceIndices_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -19292,10 +19318,7 @@
 
     BindBufferMemoryDeviceGroupInfo & operator=( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceIndexCount = rhs.deviceIndexCount;
-    pDeviceIndices = rhs.pDeviceIndices;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
       return *this;
     }
 
@@ -19384,6 +19407,8 @@
     : buffer( buffer_ ), memory( memory_ ), memoryOffset( memoryOffset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -19398,11 +19423,7 @@
 
     BindBufferMemoryInfo & operator=( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    buffer = rhs.buffer;
-    memory = rhs.memory;
-    memoryOffset = rhs.memoryOffset;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindBufferMemoryInfo ) );
       return *this;
     }
 
@@ -19489,6 +19510,8 @@
     : x( x_ ), y( y_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Offset2D( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -19501,6 +19524,12 @@
       return *this;
     }
 
+    Offset2D & operator=( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Offset2D ) );
+      return *this;
+    }
+
     Offset2D & setX( int32_t x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -19559,6 +19588,8 @@
     : offset( offset_ ), extent( extent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Rect2D( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -19571,6 +19602,12 @@
       return *this;
     }
 
+    Rect2D & operator=( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Rect2D ) );
+      return *this;
+    }
+
     Rect2D & setOffset( VULKAN_HPP_NAMESPACE::Offset2D const & offset_ ) VULKAN_HPP_NOEXCEPT
     {
       offset = offset_;
@@ -19630,6 +19667,8 @@
     : deviceIndexCount( deviceIndexCount_ ), pDeviceIndices( pDeviceIndices_ ), splitInstanceBindRegionCount( splitInstanceBindRegionCount_ ), pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -19650,12 +19689,7 @@
 
     BindImageMemoryDeviceGroupInfo & operator=( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceIndexCount = rhs.deviceIndexCount;
-    pDeviceIndices = rhs.pDeviceIndices;
-    splitInstanceBindRegionCount = rhs.splitInstanceBindRegionCount;
-    pSplitInstanceBindRegions = rhs.pSplitInstanceBindRegions;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
       return *this;
     }
 
@@ -19869,6 +19903,8 @@
     : image( image_ ), memory( memory_ ), memoryOffset( memoryOffset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -19883,11 +19919,7 @@
 
     BindImageMemoryInfo & operator=( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    image = rhs.image;
-    memory = rhs.memory;
-    memoryOffset = rhs.memoryOffset;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindImageMemoryInfo ) );
       return *this;
     }
 
@@ -19975,6 +20007,8 @@
     : swapchain( swapchain_ ), imageIndex( imageIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -19989,10 +20023,7 @@
 
     BindImageMemorySwapchainInfoKHR & operator=( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    swapchain = rhs.swapchain;
-    imageIndex = rhs.imageIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
       return *this;
     }
 
@@ -20071,6 +20102,8 @@
     : planeAspect( planeAspect_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20085,9 +20118,7 @@
 
     BindImagePlaneMemoryInfo & operator=( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    planeAspect = rhs.planeAspect;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindImagePlaneMemoryInfo ) );
       return *this;
     }
 
@@ -20158,6 +20189,8 @@
     : bufferAddress( bufferAddress_ ), size( size_ ), indexType( indexType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandNV( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindIndexBufferIndirectCommandNV( VkBindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20170,6 +20203,12 @@
       return *this;
     }
 
+    BindIndexBufferIndirectCommandNV & operator=( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindIndexBufferIndirectCommandNV ) );
+      return *this;
+    }
+
     BindIndexBufferIndirectCommandNV & setBufferAddress( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ ) VULKAN_HPP_NOEXCEPT
     {
       bufferAddress = bufferAddress_;
@@ -20236,6 +20275,8 @@
     : groupIndex( groupIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindShaderGroupIndirectCommandNV( VkBindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20248,6 +20289,12 @@
       return *this;
     }
 
+    BindShaderGroupIndirectCommandNV & operator=( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindShaderGroupIndirectCommandNV ) );
+      return *this;
+    }
+
     BindShaderGroupIndirectCommandNV & setGroupIndex( uint32_t groupIndex_ ) VULKAN_HPP_NOEXCEPT
     {
       groupIndex = groupIndex_;
@@ -20298,6 +20345,8 @@
     : resourceOffset( resourceOffset_ ), size( size_ ), memory( memory_ ), memoryOffset( memoryOffset_ ), flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseMemoryBind( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20310,6 +20359,12 @@
       return *this;
     }
 
+    SparseMemoryBind & operator=( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseMemoryBind ) );
+      return *this;
+    }
+
     SparseMemoryBind & setResourceOffset( VULKAN_HPP_NAMESPACE::DeviceSize resourceOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       resourceOffset = resourceOffset_;
@@ -20392,6 +20447,8 @@
     : buffer( buffer_ ), bindCount( bindCount_ ), pBinds( pBinds_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20410,6 +20467,12 @@
       return *this;
     }
 
+    SparseBufferMemoryBindInfo & operator=( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+      return *this;
+    }
+
     SparseBufferMemoryBindInfo & setBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer_ ) VULKAN_HPP_NOEXCEPT
     {
       buffer = buffer_;
@@ -20485,6 +20548,8 @@
     : image( image_ ), bindCount( bindCount_ ), pBinds( pBinds_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseImageOpaqueMemoryBindInfo( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20503,6 +20568,12 @@
       return *this;
     }
 
+    SparseImageOpaqueMemoryBindInfo & operator=( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+      return *this;
+    }
+
     SparseImageOpaqueMemoryBindInfo & setImage( VULKAN_HPP_NAMESPACE::Image image_ ) VULKAN_HPP_NOEXCEPT
     {
       image = image_;
@@ -20578,6 +20649,8 @@
     : aspectMask( aspectMask_ ), mipLevel( mipLevel_ ), arrayLayer( arrayLayer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageSubresource( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20590,6 +20663,12 @@
       return *this;
     }
 
+    ImageSubresource & operator=( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageSubresource ) );
+      return *this;
+    }
+
     ImageSubresource & setAspectMask( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ ) VULKAN_HPP_NOEXCEPT
     {
       aspectMask = aspectMask_;
@@ -20656,6 +20735,8 @@
     : x( x_ ), y( y_ ), z( z_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Offset3D( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20674,6 +20755,12 @@
       return *this;
     }
 
+    Offset3D & operator=( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Offset3D ) );
+      return *this;
+    }
+
     Offset3D & setX( int32_t x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -20740,6 +20827,8 @@
     : width( width_ ), height( height_ ), depth( depth_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Extent3D( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20758,6 +20847,12 @@
       return *this;
     }
 
+    Extent3D & operator=( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Extent3D ) );
+      return *this;
+    }
+
     Extent3D & setWidth( uint32_t width_ ) VULKAN_HPP_NOEXCEPT
     {
       width = width_;
@@ -20824,6 +20919,8 @@
     : subresource( subresource_ ), offset( offset_ ), extent( extent_ ), memory( memory_ ), memoryOffset( memoryOffset_ ), flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20836,6 +20933,12 @@
       return *this;
     }
 
+    SparseImageMemoryBind & operator=( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseImageMemoryBind ) );
+      return *this;
+    }
+
     SparseImageMemoryBind & setSubresource( VULKAN_HPP_NAMESPACE::ImageSubresource const & subresource_ ) VULKAN_HPP_NOEXCEPT
     {
       subresource = subresource_;
@@ -20926,6 +21029,8 @@
     : image( image_ ), bindCount( bindCount_ ), pBinds( pBinds_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseImageMemoryBindInfo( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -20944,6 +21049,12 @@
       return *this;
     }
 
+    SparseImageMemoryBindInfo & operator=( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseImageMemoryBindInfo ) );
+      return *this;
+    }
+
     SparseImageMemoryBindInfo & setImage( VULKAN_HPP_NAMESPACE::Image image_ ) VULKAN_HPP_NOEXCEPT
     {
       image = image_;
@@ -21020,6 +21131,8 @@
     : waitSemaphoreCount( waitSemaphoreCount_ ), pWaitSemaphores( pWaitSemaphores_ ), bufferBindCount( bufferBindCount_ ), pBufferBinds( pBufferBinds_ ), imageOpaqueBindCount( imageOpaqueBindCount_ ), pImageOpaqueBinds( pImageOpaqueBinds_ ), imageBindCount( imageBindCount_ ), pImageBinds( pImageBinds_ ), signalSemaphoreCount( signalSemaphoreCount_ ), pSignalSemaphores( pSignalSemaphores_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindSparseInfo( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21040,18 +21153,7 @@
 
     BindSparseInfo & operator=( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    waitSemaphoreCount = rhs.waitSemaphoreCount;
-    pWaitSemaphores = rhs.pWaitSemaphores;
-    bufferBindCount = rhs.bufferBindCount;
-    pBufferBinds = rhs.pBufferBinds;
-    imageOpaqueBindCount = rhs.imageOpaqueBindCount;
-    pImageOpaqueBinds = rhs.pImageOpaqueBinds;
-    imageBindCount = rhs.imageBindCount;
-    pImageBinds = rhs.pImageBinds;
-    signalSemaphoreCount = rhs.signalSemaphoreCount;
-    pSignalSemaphores = rhs.pSignalSemaphores;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindSparseInfo ) );
       return *this;
     }
 
@@ -21238,6 +21340,8 @@
     : bufferAddress( bufferAddress_ ), size( size_ ), stride( stride_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BindVertexBufferIndirectCommandNV( VkBindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21250,6 +21354,12 @@
       return *this;
     }
 
+    BindVertexBufferIndirectCommandNV & operator=( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BindVertexBufferIndirectCommandNV ) );
+      return *this;
+    }
+
     BindVertexBufferIndirectCommandNV & setBufferAddress( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ ) VULKAN_HPP_NOEXCEPT
     {
       bufferAddress = bufferAddress_;
@@ -21316,6 +21426,8 @@
     : srcOffset( srcOffset_ ), dstOffset( dstOffset_ ), size( size_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferCopy( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21328,6 +21440,12 @@
       return *this;
     }
 
+    BufferCopy & operator=( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferCopy ) );
+      return *this;
+    }
+
     BufferCopy & setSrcOffset( VULKAN_HPP_NAMESPACE::DeviceSize srcOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       srcOffset = srcOffset_;
@@ -21395,6 +21513,8 @@
     : flags( flags_ ), size( size_ ), usage( usage_ ), sharingMode( sharingMode_ ), queueFamilyIndexCount( queueFamilyIndexCount_ ), pQueueFamilyIndices( pQueueFamilyIndices_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferCreateInfo( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21415,14 +21535,7 @@
 
     BufferCreateInfo & operator=( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    size = rhs.size;
-    usage = rhs.usage;
-    sharingMode = rhs.sharingMode;
-    queueFamilyIndexCount = rhs.queueFamilyIndexCount;
-    pQueueFamilyIndices = rhs.pQueueFamilyIndices;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferCreateInfo ) );
       return *this;
     }
 
@@ -21542,6 +21655,8 @@
     : deviceAddress( deviceAddress_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21556,9 +21671,7 @@
 
     BufferDeviceAddressCreateInfoEXT & operator=( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceAddress = rhs.deviceAddress;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferDeviceAddressCreateInfoEXT ) );
       return *this;
     }
 
@@ -21629,6 +21742,8 @@
     : buffer( buffer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferDeviceAddressInfo( VkBufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21643,9 +21758,7 @@
 
     BufferDeviceAddressInfo & operator=( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    buffer = rhs.buffer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferDeviceAddressInfo ) );
       return *this;
     }
 
@@ -21717,6 +21830,8 @@
     : aspectMask( aspectMask_ ), mipLevel( mipLevel_ ), baseArrayLayer( baseArrayLayer_ ), layerCount( layerCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21729,6 +21844,12 @@
       return *this;
     }
 
+    ImageSubresourceLayers & operator=( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageSubresourceLayers ) );
+      return *this;
+    }
+
     ImageSubresourceLayers & setAspectMask( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ ) VULKAN_HPP_NOEXCEPT
     {
       aspectMask = aspectMask_;
@@ -21803,6 +21924,8 @@
     : bufferOffset( bufferOffset_ ), bufferRowLength( bufferRowLength_ ), bufferImageHeight( bufferImageHeight_ ), imageSubresource( imageSubresource_ ), imageOffset( imageOffset_ ), imageExtent( imageExtent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferImageCopy( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21815,6 +21938,12 @@
       return *this;
     }
 
+    BufferImageCopy & operator=( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferImageCopy ) );
+      return *this;
+    }
+
     BufferImageCopy & setBufferOffset( VULKAN_HPP_NAMESPACE::DeviceSize bufferOffset_ ) VULKAN_HPP_NOEXCEPT
     {
       bufferOffset = bufferOffset_;
@@ -21906,6 +22035,8 @@
     : srcAccessMask( srcAccessMask_ ), dstAccessMask( dstAccessMask_ ), srcQueueFamilyIndex( srcQueueFamilyIndex_ ), dstQueueFamilyIndex( dstQueueFamilyIndex_ ), buffer( buffer_ ), offset( offset_ ), size( size_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -21920,15 +22051,7 @@
 
     BufferMemoryBarrier & operator=( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    srcAccessMask = rhs.srcAccessMask;
-    dstAccessMask = rhs.dstAccessMask;
-    srcQueueFamilyIndex = rhs.srcQueueFamilyIndex;
-    dstQueueFamilyIndex = rhs.dstQueueFamilyIndex;
-    buffer = rhs.buffer;
-    offset = rhs.offset;
-    size = rhs.size;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferMemoryBarrier ) );
       return *this;
     }
 
@@ -22047,6 +22170,8 @@
     : buffer( buffer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22061,9 +22186,7 @@
 
     BufferMemoryRequirementsInfo2 & operator=( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    buffer = rhs.buffer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
       return *this;
     }
 
@@ -22135,6 +22258,8 @@
     : opaqueCaptureAddress( opaqueCaptureAddress_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferOpaqueCaptureAddressCreateInfo( VkBufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22149,9 +22274,7 @@
 
     BufferOpaqueCaptureAddressCreateInfo & operator=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    opaqueCaptureAddress = rhs.opaqueCaptureAddress;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferOpaqueCaptureAddressCreateInfo ) );
       return *this;
     }
 
@@ -22223,6 +22346,8 @@
     : flags( flags_ ), buffer( buffer_ ), format( format_ ), offset( offset_ ), range( range_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22237,13 +22362,7 @@
 
     BufferViewCreateInfo & operator=( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    buffer = rhs.buffer;
-    format = rhs.format;
-    offset = rhs.offset;
-    range = rhs.range;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( BufferViewCreateInfo ) );
       return *this;
     }
 
@@ -22346,6 +22465,8 @@
     : timeDomain( timeDomain_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( CalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22360,9 +22481,7 @@
 
     CalibratedTimestampInfoEXT & operator=( CalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    timeDomain = rhs.timeDomain;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CalibratedTimestampInfoEXT ) );
       return *this;
     }
 
@@ -22433,6 +22552,8 @@
     : stage( stage_ ), pCheckpointMarker( pCheckpointMarker_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CheckpointDataNV( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22447,10 +22568,7 @@
 
     CheckpointDataNV & operator=( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    stage = rhs.stage;
-    pCheckpointMarker = rhs.pCheckpointMarker;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CheckpointDataNV ) );
       return *this;
     }
 
@@ -22568,6 +22686,8 @@
     : depth( depth_ ), stencil( stencil_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22580,6 +22700,12 @@
       return *this;
     }
 
+    ClearDepthStencilValue & operator=( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ClearDepthStencilValue ) );
+      return *this;
+    }
+
     ClearDepthStencilValue & setDepth( float depth_ ) VULKAN_HPP_NOEXCEPT
     {
       depth = depth_;
@@ -22690,6 +22816,8 @@
     : aspectMask( aspectMask_ ), colorAttachment( colorAttachment_ ), clearValue( clearValue_ )
     {}
 
+    ClearAttachment( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22702,6 +22830,12 @@
       return *this;
     }
 
+    ClearAttachment & operator=( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ClearAttachment ) );
+      return *this;
+    }
+
     ClearAttachment & setAspectMask( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ ) VULKAN_HPP_NOEXCEPT
     {
       aspectMask = aspectMask_;
@@ -22752,6 +22886,8 @@
     : rect( rect_ ), baseArrayLayer( baseArrayLayer_ ), layerCount( layerCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ClearRect( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22764,6 +22900,12 @@
       return *this;
     }
 
+    ClearRect & operator=( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ClearRect ) );
+      return *this;
+    }
+
     ClearRect & setRect( VULKAN_HPP_NAMESPACE::Rect2D const & rect_ ) VULKAN_HPP_NOEXCEPT
     {
       rect = rect_;
@@ -22830,6 +22972,8 @@
     : pixelX( pixelX_ ), pixelY( pixelY_ ), sample( sample_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22842,6 +22986,12 @@
       return *this;
     }
 
+    CoarseSampleLocationNV & operator=( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CoarseSampleLocationNV ) );
+      return *this;
+    }
+
     CoarseSampleLocationNV & setPixelX( uint32_t pixelX_ ) VULKAN_HPP_NOEXCEPT
     {
       pixelX = pixelX_;
@@ -22908,6 +23058,8 @@
     : shadingRate( shadingRate_ ), sampleCount( sampleCount_ ), sampleLocationCount( sampleLocationCount_ ), pSampleLocations( pSampleLocations_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -22926,6 +23078,12 @@
       return *this;
     }
 
+    CoarseSampleOrderCustomNV & operator=( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CoarseSampleOrderCustomNV ) );
+      return *this;
+    }
+
     CoarseSampleOrderCustomNV & setShadingRate( VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV shadingRate_ ) VULKAN_HPP_NOEXCEPT
     {
       shadingRate = shadingRate_;
@@ -23110,6 +23268,8 @@
     : commandPool( commandPool_ ), level( level_ ), commandBufferCount( commandBufferCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -23124,11 +23284,7 @@
 
     CommandBufferAllocateInfo & operator=( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    commandPool = rhs.commandPool;
-    level = rhs.level;
-    commandBufferCount = rhs.commandBufferCount;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CommandBufferAllocateInfo ) );
       return *this;
     }
 
@@ -23415,6 +23571,8 @@
     : renderPass( renderPass_ ), subpass( subpass_ ), framebuffer( framebuffer_ ), occlusionQueryEnable( occlusionQueryEnable_ ), queryFlags( queryFlags_ ), pipelineStatistics( pipelineStatistics_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -23429,14 +23587,7 @@
 
     CommandBufferInheritanceInfo & operator=( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    renderPass = rhs.renderPass;
-    subpass = rhs.subpass;
-    framebuffer = rhs.framebuffer;
-    occlusionQueryEnable = rhs.occlusionQueryEnable;
-    queryFlags = rhs.queryFlags;
-    pipelineStatistics = rhs.pipelineStatistics;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CommandBufferInheritanceInfo ) );
       return *this;
     }
 
@@ -23547,6 +23698,8 @@
     : flags( flags_ ), pInheritanceInfo( pInheritanceInfo_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -23561,10 +23714,7 @@
 
     CommandBufferBeginInfo & operator=( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pInheritanceInfo = rhs.pInheritanceInfo;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CommandBufferBeginInfo ) );
       return *this;
     }
 
@@ -23643,6 +23793,8 @@
     : conditionalRenderingEnable( conditionalRenderingEnable_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -23657,9 +23809,7 @@
 
     CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    conditionalRenderingEnable = rhs.conditionalRenderingEnable;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) );
       return *this;
     }
 
@@ -23730,6 +23880,8 @@
     : transform( transform_ ), renderArea( renderArea_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderPassTransformInfoQCOM( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CommandBufferInheritanceRenderPassTransformInfoQCOM( VkCommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -23744,10 +23896,7 @@
 
     CommandBufferInheritanceRenderPassTransformInfoQCOM & operator=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    transform = rhs.transform;
-    renderArea = rhs.renderArea;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CommandBufferInheritanceRenderPassTransformInfoQCOM ) );
       return *this;
     }
 
@@ -23826,6 +23975,8 @@
     : flags( flags_ ), queueFamilyIndex( queueFamilyIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -23840,10 +23991,7 @@
 
     CommandPoolCreateInfo & operator=( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    queueFamilyIndex = rhs.queueFamilyIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CommandPoolCreateInfo ) );
       return *this;
     }
 
@@ -24021,6 +24169,8 @@
     : constantID( constantID_ ), offset( offset_ ), size( size_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SpecializationMapEntry( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -24033,6 +24183,12 @@
       return *this;
     }
 
+    SpecializationMapEntry & operator=( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SpecializationMapEntry ) );
+      return *this;
+    }
+
     SpecializationMapEntry & setConstantID( uint32_t constantID_ ) VULKAN_HPP_NOEXCEPT
     {
       constantID = constantID_;
@@ -24099,6 +24255,8 @@
     : mapEntryCount( mapEntryCount_ ), pMapEntries( pMapEntries_ ), dataSize( dataSize_ ), pData( pData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SpecializationInfo( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -24118,6 +24276,12 @@
       return *this;
     }
 
+    SpecializationInfo & operator=( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SpecializationInfo ) );
+      return *this;
+    }
+
     SpecializationInfo & setMapEntryCount( uint32_t mapEntryCount_ ) VULKAN_HPP_NOEXCEPT
     {
       mapEntryCount = mapEntryCount_;
@@ -24212,6 +24376,8 @@
     : flags( flags_ ), stage( stage_ ), module( module_ ), pName( pName_ ), pSpecializationInfo( pSpecializationInfo_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -24226,13 +24392,7 @@
 
     PipelineShaderStageCreateInfo & operator=( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    stage = rhs.stage;
-    module = rhs.module;
-    pName = rhs.pName;
-    pSpecializationInfo = rhs.pSpecializationInfo;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineShaderStageCreateInfo ) );
       return *this;
     }
 
@@ -24535,6 +24695,8 @@
     : flags( flags_ ), stage( stage_ ), layout( layout_ ), basePipelineHandle( basePipelineHandle_ ), basePipelineIndex( basePipelineIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -24549,13 +24711,7 @@
 
     ComputePipelineCreateInfo & operator=( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    stage = rhs.stage;
-    layout = rhs.layout;
-    basePipelineHandle = rhs.basePipelineHandle;
-    basePipelineIndex = rhs.basePipelineIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ComputePipelineCreateInfo ) );
       return *this;
     }
 
@@ -24658,6 +24814,8 @@
     : buffer( buffer_ ), offset( offset_ ), flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -24672,11 +24830,7 @@
 
     ConditionalRenderingBeginInfoEXT & operator=( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    buffer = rhs.buffer;
-    offset = rhs.offset;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
       return *this;
     }
 
@@ -24762,6 +24916,8 @@
     : major( major_ ), minor( minor_ ), subminor( subminor_ ), patch( patch_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ConformanceVersion( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ConformanceVersion( VkConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -24774,6 +24930,12 @@
       return *this;
     }
 
+    ConformanceVersion & operator=( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ConformanceVersion ) );
+      return *this;
+    }
+
     ConformanceVersion & setMajor( uint8_t major_ ) VULKAN_HPP_NOEXCEPT
     {
       major = major_;
@@ -24850,6 +25012,8 @@
     : MSize( MSize_ ), NSize( NSize_ ), KSize( KSize_ ), AType( AType_ ), BType( BType_ ), CType( CType_ ), DType( DType_ ), scope( scope_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -24864,16 +25028,7 @@
 
     CooperativeMatrixPropertiesNV & operator=( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    MSize = rhs.MSize;
-    NSize = rhs.NSize;
-    KSize = rhs.KSize;
-    AType = rhs.AType;
-    BType = rhs.BType;
-    CType = rhs.CType;
-    DType = rhs.DType;
-    scope = rhs.scope;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CooperativeMatrixPropertiesNV ) );
       return *this;
     }
 
@@ -25001,6 +25156,8 @@
     : src( src_ ), dst( dst_ ), mode( mode_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CopyAccelerationStructureInfoKHR( VkCopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -25015,11 +25172,7 @@
 
     CopyAccelerationStructureInfoKHR & operator=( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    src = rhs.src;
-    dst = rhs.dst;
-    mode = rhs.mode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CopyAccelerationStructureInfoKHR ) );
       return *this;
     }
 
@@ -25108,6 +25261,8 @@
     : src( src_ ), dst( dst_ ), mode( mode_ )
     {}
 
+    CopyAccelerationStructureToMemoryInfoKHR( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CopyAccelerationStructureToMemoryInfoKHR( VkCopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -25122,11 +25277,7 @@
 
     CopyAccelerationStructureToMemoryInfoKHR & operator=( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    src = rhs.src;
-    dst = rhs.dst;
-    mode = rhs.mode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CopyAccelerationStructureToMemoryInfoKHR ) );
       return *this;
     }
 
@@ -25296,6 +25447,8 @@
     : srcSet( srcSet_ ), srcBinding( srcBinding_ ), srcArrayElement( srcArrayElement_ ), dstSet( dstSet_ ), dstBinding( dstBinding_ ), dstArrayElement( dstArrayElement_ ), descriptorCount( descriptorCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR CopyDescriptorSet( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -25310,15 +25463,7 @@
 
     CopyDescriptorSet & operator=( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    srcSet = rhs.srcSet;
-    srcBinding = rhs.srcBinding;
-    srcArrayElement = rhs.srcArrayElement;
-    dstSet = rhs.dstSet;
-    dstBinding = rhs.dstBinding;
-    dstArrayElement = rhs.dstArrayElement;
-    descriptorCount = rhs.descriptorCount;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CopyDescriptorSet ) );
       return *this;
     }
 
@@ -25438,6 +25583,8 @@
     : src( src_ ), dst( dst_ ), mode( mode_ )
     {}
 
+    CopyMemoryToAccelerationStructureInfoKHR( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     CopyMemoryToAccelerationStructureInfoKHR( VkCopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -25452,11 +25599,7 @@
 
     CopyMemoryToAccelerationStructureInfoKHR & operator=( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    src = rhs.src;
-    dst = rhs.dst;
-    mode = rhs.mode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( CopyMemoryToAccelerationStructureInfoKHR ) );
       return *this;
     }
 
@@ -25527,6 +25670,8 @@
     : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ), pWaitSemaphoreValues( pWaitSemaphoreValues_ ), signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ), pSignalSemaphoreValues( pSignalSemaphoreValues_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -25547,12 +25692,7 @@
 
     D3D12FenceSubmitInfoKHR & operator=( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    waitSemaphoreValuesCount = rhs.waitSemaphoreValuesCount;
-    pWaitSemaphoreValues = rhs.pWaitSemaphoreValues;
-    signalSemaphoreValuesCount = rhs.signalSemaphoreValuesCount;
-    pSignalSemaphoreValues = rhs.pSignalSemaphoreValues;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
       return *this;
     }
 
@@ -25666,6 +25806,8 @@
     : pMarkerName( pMarkerName_ ), color( color_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -25680,10 +25822,7 @@
 
     DebugMarkerMarkerInfoEXT & operator=( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pMarkerName = rhs.pMarkerName;
-    color = rhs.color;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
       return *this;
     }
 
@@ -25762,6 +25901,8 @@
     : objectType( objectType_ ), object( object_ ), pObjectName( pObjectName_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -25776,11 +25917,7 @@
 
     DebugMarkerObjectNameInfoEXT & operator=( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    objectType = rhs.objectType;
-    object = rhs.object;
-    pObjectName = rhs.pObjectName;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
       return *this;
     }
 
@@ -25867,6 +26004,8 @@
     : objectType( objectType_ ), object( object_ ), tagName( tagName_ ), tagSize( tagSize_ ), pTag( pTag_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -25888,13 +26027,7 @@
 
     DebugMarkerObjectTagInfoEXT & operator=( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    objectType = rhs.objectType;
-    object = rhs.object;
-    tagName = rhs.tagName;
-    tagSize = rhs.tagSize;
-    pTag = rhs.pTag;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
       return *this;
     }
 
@@ -26007,6 +26140,8 @@
     : flags( flags_ ), pfnCallback( pfnCallback_ ), pUserData( pUserData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26021,11 +26156,7 @@
 
     DebugReportCallbackCreateInfoEXT & operator=( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pfnCallback = rhs.pfnCallback;
-    pUserData = rhs.pUserData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
       return *this;
     }
 
@@ -26112,6 +26243,8 @@
     : pLabelName( pLabelName_ ), color( color_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26126,10 +26259,7 @@
 
     DebugUtilsLabelEXT & operator=( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pLabelName = rhs.pLabelName;
-    color = rhs.color;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugUtilsLabelEXT ) );
       return *this;
     }
 
@@ -26208,6 +26338,8 @@
     : objectType( objectType_ ), objectHandle( objectHandle_ ), pObjectName( pObjectName_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26222,11 +26354,7 @@
 
     DebugUtilsObjectNameInfoEXT & operator=( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    objectType = rhs.objectType;
-    objectHandle = rhs.objectHandle;
-    pObjectName = rhs.pObjectName;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
       return *this;
     }
 
@@ -26313,6 +26441,8 @@
     : flags( flags_ ), pMessageIdName( pMessageIdName_ ), messageIdNumber( messageIdNumber_ ), pMessage( pMessage_ ), queueLabelCount( queueLabelCount_ ), pQueueLabels( pQueueLabels_ ), cmdBufLabelCount( cmdBufLabelCount_ ), pCmdBufLabels( pCmdBufLabels_ ), objectCount( objectCount_ ), pObjects( pObjects_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26333,18 +26463,7 @@
 
     DebugUtilsMessengerCallbackDataEXT & operator=( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pMessageIdName = rhs.pMessageIdName;
-    messageIdNumber = rhs.messageIdNumber;
-    pMessage = rhs.pMessage;
-    queueLabelCount = rhs.queueLabelCount;
-    pQueueLabels = rhs.pQueueLabels;
-    cmdBufLabelCount = rhs.cmdBufLabelCount;
-    pCmdBufLabels = rhs.pCmdBufLabels;
-    objectCount = rhs.objectCount;
-    pObjects = rhs.pObjects;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
       return *this;
     }
 
@@ -26514,6 +26633,8 @@
     : flags( flags_ ), messageSeverity( messageSeverity_ ), messageType( messageType_ ), pfnUserCallback( pfnUserCallback_ ), pUserData( pUserData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26528,13 +26649,7 @@
 
     DebugUtilsMessengerCreateInfoEXT & operator=( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    messageSeverity = rhs.messageSeverity;
-    messageType = rhs.messageType;
-    pfnUserCallback = rhs.pfnUserCallback;
-    pUserData = rhs.pUserData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
       return *this;
     }
 
@@ -26637,6 +26752,8 @@
     : objectType( objectType_ ), objectHandle( objectHandle_ ), tagName( tagName_ ), tagSize( tagSize_ ), pTag( pTag_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26658,13 +26775,7 @@
 
     DebugUtilsObjectTagInfoEXT & operator=( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    objectType = rhs.objectType;
-    objectHandle = rhs.objectHandle;
-    tagName = rhs.tagName;
-    tagSize = rhs.tagSize;
-    pTag = rhs.pTag;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
       return *this;
     }
 
@@ -26777,6 +26888,8 @@
     : dedicatedAllocation( dedicatedAllocation_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26791,9 +26904,7 @@
 
     DedicatedAllocationBufferCreateInfoNV & operator=( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    dedicatedAllocation = rhs.dedicatedAllocation;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
       return *this;
     }
 
@@ -26864,6 +26975,8 @@
     : dedicatedAllocation( dedicatedAllocation_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26878,9 +26991,7 @@
 
     DedicatedAllocationImageCreateInfoNV & operator=( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    dedicatedAllocation = rhs.dedicatedAllocation;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
       return *this;
     }
 
@@ -26951,6 +27062,8 @@
     : image( image_ ), buffer( buffer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -26965,10 +27078,7 @@
 
     DedicatedAllocationMemoryAllocateInfoNV & operator=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    image = rhs.image;
-    buffer = rhs.buffer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
       return *this;
     }
 
@@ -27144,6 +27254,8 @@
     : operationHandle( operationHandle_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeferredOperationInfoKHR( DeferredOperationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeferredOperationInfoKHR( VkDeferredOperationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -27158,9 +27270,7 @@
 
     DeferredOperationInfoKHR & operator=( DeferredOperationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    operationHandle = rhs.operationHandle;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeferredOperationInfoKHR ) );
       return *this;
     }
 
@@ -27231,6 +27341,8 @@
     : buffer( buffer_ ), offset( offset_ ), range( range_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -27243,6 +27355,12 @@
       return *this;
     }
 
+    DescriptorBufferInfo & operator=( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorBufferInfo ) );
+      return *this;
+    }
+
     DescriptorBufferInfo & setBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer_ ) VULKAN_HPP_NOEXCEPT
     {
       buffer = buffer_;
@@ -27509,6 +27627,8 @@
     : sampler( sampler_ ), imageView( imageView_ ), imageLayout( imageLayout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorImageInfo( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -27521,6 +27641,12 @@
       return *this;
     }
 
+    DescriptorImageInfo & operator=( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorImageInfo ) );
+      return *this;
+    }
+
     DescriptorImageInfo & setSampler( VULKAN_HPP_NAMESPACE::Sampler sampler_ ) VULKAN_HPP_NOEXCEPT
     {
       sampler = sampler_;
@@ -27587,6 +27713,8 @@
     : type( type_ ), descriptorCount( descriptorCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -27599,6 +27727,12 @@
       return *this;
     }
 
+    DescriptorPoolSize & operator=( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorPoolSize ) );
+      return *this;
+    }
+
     DescriptorPoolSize & setType( VULKAN_HPP_NAMESPACE::DescriptorType type_ ) VULKAN_HPP_NOEXCEPT
     {
       type = type_;
@@ -27658,6 +27792,8 @@
     : flags( flags_ ), maxSets( maxSets_ ), poolSizeCount( poolSizeCount_ ), pPoolSizes( pPoolSizes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -27678,12 +27814,7 @@
 
     DescriptorPoolCreateInfo & operator=( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    maxSets = rhs.maxSets;
-    poolSizeCount = rhs.poolSizeCount;
-    pPoolSizes = rhs.pPoolSizes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorPoolCreateInfo ) );
       return *this;
     }
 
@@ -27787,6 +27918,8 @@
     : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -27801,9 +27934,7 @@
 
     DescriptorPoolInlineUniformBlockCreateInfoEXT & operator=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxInlineUniformBlockBindings = rhs.maxInlineUniformBlockBindings;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
       return *this;
     }
 
@@ -28074,6 +28205,8 @@
     : descriptorPool( descriptorPool_ ), descriptorSetCount( descriptorSetCount_ ), pSetLayouts( pSetLayouts_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28094,11 +28227,7 @@
 
     DescriptorSetAllocateInfo & operator=( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    descriptorPool = rhs.descriptorPool;
-    descriptorSetCount = rhs.descriptorSetCount;
-    pSetLayouts = rhs.pSetLayouts;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorSetAllocateInfo ) );
       return *this;
     }
 
@@ -28193,6 +28322,8 @@
     : binding( binding_ ), descriptorType( descriptorType_ ), descriptorCount( descriptorCount_ ), stageFlags( stageFlags_ ), pImmutableSamplers( pImmutableSamplers_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28211,6 +28342,12 @@
       return *this;
     }
 
+    DescriptorSetLayoutBinding & operator=( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorSetLayoutBinding ) );
+      return *this;
+    }
+
     DescriptorSetLayoutBinding & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
     {
       binding = binding_;
@@ -28303,6 +28440,8 @@
     : bindingCount( bindingCount_ ), pBindingFlags( pBindingFlags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorSetLayoutBindingFlagsCreateInfo( VkDescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28323,10 +28462,7 @@
 
     DescriptorSetLayoutBindingFlagsCreateInfo & operator=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    bindingCount = rhs.bindingCount;
-    pBindingFlags = rhs.pBindingFlags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfo ) );
       return *this;
     }
 
@@ -28415,6 +28551,8 @@
     : flags( flags_ ), bindingCount( bindingCount_ ), pBindings( pBindings_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28435,11 +28573,7 @@
 
     DescriptorSetLayoutCreateInfo & operator=( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    bindingCount = rhs.bindingCount;
-    pBindings = rhs.pBindings;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
       return *this;
     }
 
@@ -28535,6 +28669,8 @@
     : supported( supported_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28549,9 +28685,7 @@
 
     DescriptorSetLayoutSupport & operator=( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    supported = rhs.supported;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorSetLayoutSupport ) );
       return *this;
     }
 
@@ -28611,6 +28745,8 @@
     : descriptorSetCount( descriptorSetCount_ ), pDescriptorCounts( pDescriptorCounts_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfo( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorSetVariableDescriptorCountAllocateInfo( VkDescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28631,10 +28767,7 @@
 
     DescriptorSetVariableDescriptorCountAllocateInfo & operator=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    descriptorSetCount = rhs.descriptorSetCount;
-    pDescriptorCounts = rhs.pDescriptorCounts;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfo ) );
       return *this;
     }
 
@@ -28723,6 +28856,8 @@
     : maxVariableDescriptorCount( maxVariableDescriptorCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupport( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorSetVariableDescriptorCountLayoutSupport( VkDescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28737,9 +28872,7 @@
 
     DescriptorSetVariableDescriptorCountLayoutSupport & operator=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxVariableDescriptorCount = rhs.maxVariableDescriptorCount;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorSetVariableDescriptorCountLayoutSupport ) );
       return *this;
     }
 
@@ -28798,6 +28931,8 @@
     : dstBinding( dstBinding_ ), dstArrayElement( dstArrayElement_ ), descriptorCount( descriptorCount_ ), descriptorType( descriptorType_ ), offset( offset_ ), stride( stride_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28810,6 +28945,12 @@
       return *this;
     }
 
+    DescriptorUpdateTemplateEntry & operator=( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
+      return *this;
+    }
+
     DescriptorUpdateTemplateEntry & setDstBinding( uint32_t dstBinding_ ) VULKAN_HPP_NOEXCEPT
     {
       dstBinding = dstBinding_;
@@ -28902,6 +29043,8 @@
     : flags( flags_ ), descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ), pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ), templateType( templateType_ ), descriptorSetLayout( descriptorSetLayout_ ), pipelineBindPoint( pipelineBindPoint_ ), pipelineLayout( pipelineLayout_ ), set( set_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -28922,16 +29065,7 @@
 
     DescriptorUpdateTemplateCreateInfo & operator=( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    descriptorUpdateEntryCount = rhs.descriptorUpdateEntryCount;
-    pDescriptorUpdateEntries = rhs.pDescriptorUpdateEntries;
-    templateType = rhs.templateType;
-    descriptorSetLayout = rhs.descriptorSetLayout;
-    pipelineBindPoint = rhs.pipelineBindPoint;
-    pipelineLayout = rhs.pipelineLayout;
-    set = rhs.set;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
       return *this;
     }
 
@@ -29068,6 +29202,8 @@
     : flags( flags_ ), queueFamilyIndex( queueFamilyIndex_ ), queueCount( queueCount_ ), pQueuePriorities( pQueuePriorities_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -29088,12 +29224,7 @@
 
     DeviceQueueCreateInfo & operator=( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    queueFamilyIndex = rhs.queueFamilyIndex;
-    queueCount = rhs.queueCount;
-    pQueuePriorities = rhs.pQueuePriorities;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceQueueCreateInfo ) );
       return *this;
     }
 
@@ -29196,6 +29327,8 @@
     : robustBufferAccess( robustBufferAccess_ ), fullDrawIndexUint32( fullDrawIndexUint32_ ), imageCubeArray( imageCubeArray_ ), independentBlend( independentBlend_ ), geometryShader( geometryShader_ ), tessellationShader( tessellationShader_ ), sampleRateShading( sampleRateShading_ ), dualSrcBlend( dualSrcBlend_ ), logicOp( logicOp_ ), multiDrawIndirect( multiDrawIndirect_ ), drawIndirectFirstInstance( drawIndirectFirstInstance_ ), depthClamp( depthClamp_ ), depthBiasClamp( depthBiasClamp_ ), fillModeNonSolid( fillModeNonSolid_ ), depthBounds( depthBounds_ ), wideLines( wideLines_ ), largePoints( largePoints_ ), alphaToOne( alphaToOne_ ), multiViewport( multiViewport_ ), samplerAnisotropy( samplerAnisotropy_ ), textureCompressionETC2( textureCompressionETC2_ ), textureCompressionASTC_LDR( textureCompressionASTC_LDR_ ), textureCompressionBC( textureCompressionBC_ ), occlusionQueryPrecise( occlusionQueryPrecise_ ), pipelineStatisticsQuery( pipelineStatisticsQuery_ ), vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ ), fragmentStoresAndAtomics( fragmentStoresAndAtomics_ ), shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ ), shaderImageGatherExtended( shaderImageGatherExtended_ ), shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ ), shaderStorageImageMultisample( shaderStorageImageMultisample_ ), shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ ), shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ ), shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ ), shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ ), shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ ), shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ ), shaderClipDistance( shaderClipDistance_ ), shaderCullDistance( shaderCullDistance_ ), shaderFloat64( shaderFloat64_ ), shaderInt64( shaderInt64_ ), shaderInt16( shaderInt16_ ), shaderResourceResidency( shaderResourceResidency_ ), shaderResourceMinLod( shaderResourceMinLod_ ), sparseBinding( sparseBinding_ ), sparseResidencyBuffer( sparseResidencyBuffer_ ), sparseResidencyImage2D( sparseResidencyImage2D_ ), sparseResidencyImage3D( sparseResidencyImage3D_ ), sparseResidency2Samples( sparseResidency2Samples_ ), sparseResidency4Samples( sparseResidency4Samples_ ), sparseResidency8Samples( sparseResidency8Samples_ ), sparseResidency16Samples( sparseResidency16Samples_ ), sparseResidencyAliased( sparseResidencyAliased_ ), variableMultisampleRate( variableMultisampleRate_ ), inheritedQueries( inheritedQueries_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -29208,6 +29341,12 @@
       return *this;
     }
 
+    PhysicalDeviceFeatures & operator=( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFeatures ) );
+      return *this;
+    }
+
     PhysicalDeviceFeatures & setRobustBufferAccess( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess_ ) VULKAN_HPP_NOEXCEPT
     {
       robustBufferAccess = robustBufferAccess_;
@@ -29691,6 +29830,8 @@
     : flags( flags_ ), queueCreateInfoCount( queueCreateInfoCount_ ), pQueueCreateInfos( pQueueCreateInfos_ ), enabledLayerCount( enabledLayerCount_ ), ppEnabledLayerNames( ppEnabledLayerNames_ ), enabledExtensionCount( enabledExtensionCount_ ), ppEnabledExtensionNames( ppEnabledExtensionNames_ ), pEnabledFeatures( pEnabledFeatures_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceCreateInfo( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -29711,16 +29852,7 @@
 
     DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    queueCreateInfoCount = rhs.queueCreateInfoCount;
-    pQueueCreateInfos = rhs.pQueueCreateInfos;
-    enabledLayerCount = rhs.enabledLayerCount;
-    ppEnabledLayerNames = rhs.ppEnabledLayerNames;
-    enabledExtensionCount = rhs.enabledExtensionCount;
-    ppEnabledExtensionNames = rhs.ppEnabledExtensionNames;
-    pEnabledFeatures = rhs.pEnabledFeatures;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceCreateInfo ) );
       return *this;
     }
 
@@ -29874,6 +30006,8 @@
     : flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceDiagnosticsConfigCreateInfoNV( VkDeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -29888,9 +30022,7 @@
 
     DeviceDiagnosticsConfigCreateInfoNV & operator=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceDiagnosticsConfigCreateInfoNV ) );
       return *this;
     }
 
@@ -29961,6 +30093,8 @@
     : deviceEvent( deviceEvent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -29975,9 +30109,7 @@
 
     DeviceEventInfoEXT & operator=( DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceEvent = rhs.deviceEvent;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceEventInfoEXT ) );
       return *this;
     }
 
@@ -30048,6 +30180,8 @@
     : resourceDeviceIndex( resourceDeviceIndex_ ), memoryDeviceIndex( memoryDeviceIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -30062,10 +30196,7 @@
 
     DeviceGroupBindSparseInfo & operator=( DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    resourceDeviceIndex = rhs.resourceDeviceIndex;
-    memoryDeviceIndex = rhs.memoryDeviceIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceGroupBindSparseInfo ) );
       return *this;
     }
 
@@ -30145,6 +30276,8 @@
     : deviceMask( deviceMask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -30159,9 +30292,7 @@
 
     DeviceGroupCommandBufferBeginInfo & operator=( DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceMask = rhs.deviceMask;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
       return *this;
     }
 
@@ -30333,6 +30464,8 @@
     : type( type_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -30347,9 +30480,7 @@
 
     PerformanceConfigurationAcquireInfoINTEL & operator=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    type = rhs.type;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PerformanceConfigurationAcquireInfoINTEL ) );
       return *this;
     }
 
@@ -30614,6 +30745,8 @@
     : renderPass( renderPass_ ), framebuffer( framebuffer_ ), renderArea( renderArea_ ), clearValueCount( clearValueCount_ ), pClearValues( pClearValues_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -30634,13 +30767,7 @@
 
     RenderPassBeginInfo & operator=( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    renderPass = rhs.renderPass;
-    framebuffer = rhs.framebuffer;
-    renderArea = rhs.renderArea;
-    clearValueCount = rhs.clearValueCount;
-    pClearValues = rhs.pClearValues;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassBeginInfo ) );
       return *this;
     }
 
@@ -30752,6 +30879,8 @@
     : contents( contents_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubpassBeginInfo( SubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubpassBeginInfo( VkSubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -30766,9 +30895,7 @@
 
     SubpassBeginInfo & operator=( SubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    contents = rhs.contents;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubpassBeginInfo ) );
       return *this;
     }
 
@@ -30839,6 +30966,8 @@
     : srcSubresource( srcSubresource_ ), srcOffsets( srcOffsets_ ), dstSubresource( dstSubresource_ ), dstOffsets( dstOffsets_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 ImageBlit( ImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageBlit( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -30851,6 +30980,12 @@
       return *this;
     }
 
+    ImageBlit & operator=( ImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageBlit ) );
+      return *this;
+    }
+
     ImageBlit & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       srcSubresource = srcSubresource_;
@@ -30925,6 +31060,8 @@
     : aspectMask( aspectMask_ ), baseMipLevel( baseMipLevel_ ), levelCount( levelCount_ ), baseArrayLayer( baseArrayLayer_ ), layerCount( layerCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageSubresourceRange( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -30937,6 +31074,12 @@
       return *this;
     }
 
+    ImageSubresourceRange & operator=( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageSubresourceRange ) );
+      return *this;
+    }
+
     ImageSubresourceRange & setAspectMask( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ ) VULKAN_HPP_NOEXCEPT
     {
       aspectMask = aspectMask_;
@@ -31019,6 +31162,8 @@
     : srcSubresource( srcSubresource_ ), srcOffset( srcOffset_ ), dstSubresource( dstSubresource_ ), dstOffset( dstOffset_ ), extent( extent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageCopy( ImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageCopy( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -31031,6 +31176,12 @@
       return *this;
     }
 
+    ImageCopy & operator=( ImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageCopy ) );
+      return *this;
+    }
+
     ImageCopy & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       srcSubresource = srcSubresource_;
@@ -31114,6 +31265,8 @@
     
     {}
 
+    VULKAN_HPP_CONSTEXPR SubpassEndInfo( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubpassEndInfo( VkSubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -31128,8 +31281,7 @@
 
     SubpassEndInfo & operator=( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubpassEndInfo ) );
       return *this;
     }
 
@@ -31286,6 +31438,8 @@
     : buffer( buffer_ ), offset( offset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( IndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     IndirectCommandsStreamNV( VkIndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -31298,6 +31452,12 @@
       return *this;
     }
 
+    IndirectCommandsStreamNV & operator=( IndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( IndirectCommandsStreamNV ) );
+      return *this;
+    }
+
     IndirectCommandsStreamNV & setBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer_ ) VULKAN_HPP_NOEXCEPT
     {
       buffer = buffer_;
@@ -31357,6 +31517,8 @@
     : pipelineBindPoint( pipelineBindPoint_ ), pipeline( pipeline_ ), indirectCommandsLayout( indirectCommandsLayout_ ), streamCount( streamCount_ ), pStreams( pStreams_ ), sequencesCount( sequencesCount_ ), preprocessBuffer( preprocessBuffer_ ), preprocessOffset( preprocessOffset_ ), preprocessSize( preprocessSize_ ), sequencesCountBuffer( sequencesCountBuffer_ ), sequencesCountOffset( sequencesCountOffset_ ), sequencesIndexBuffer( sequencesIndexBuffer_ ), sequencesIndexOffset( sequencesIndexOffset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( GeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GeneratedCommandsInfoNV( VkGeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -31377,21 +31539,7 @@
 
     GeneratedCommandsInfoNV & operator=( GeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pipelineBindPoint = rhs.pipelineBindPoint;
-    pipeline = rhs.pipeline;
-    indirectCommandsLayout = rhs.indirectCommandsLayout;
-    streamCount = rhs.streamCount;
-    pStreams = rhs.pStreams;
-    sequencesCount = rhs.sequencesCount;
-    preprocessBuffer = rhs.preprocessBuffer;
-    preprocessOffset = rhs.preprocessOffset;
-    preprocessSize = rhs.preprocessSize;
-    sequencesCountBuffer = rhs.sequencesCountBuffer;
-    sequencesCountOffset = rhs.sequencesCountOffset;
-    sequencesIndexBuffer = rhs.sequencesIndexBuffer;
-    sequencesIndexOffset = rhs.sequencesIndexOffset;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GeneratedCommandsInfoNV ) );
       return *this;
     }
 
@@ -31567,6 +31715,8 @@
     : srcAccessMask( srcAccessMask_ ), dstAccessMask( dstAccessMask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryBarrier( MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -31581,10 +31731,7 @@
 
     MemoryBarrier & operator=( MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    srcAccessMask = rhs.srcAccessMask;
-    dstAccessMask = rhs.dstAccessMask;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryBarrier ) );
       return *this;
     }
 
@@ -31663,6 +31810,8 @@
     : srcAccessMask( srcAccessMask_ ), dstAccessMask( dstAccessMask_ ), oldLayout( oldLayout_ ), newLayout( newLayout_ ), srcQueueFamilyIndex( srcQueueFamilyIndex_ ), dstQueueFamilyIndex( dstQueueFamilyIndex_ ), image( image_ ), subresourceRange( subresourceRange_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -31677,16 +31826,7 @@
 
     ImageMemoryBarrier & operator=( ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    srcAccessMask = rhs.srcAccessMask;
-    dstAccessMask = rhs.dstAccessMask;
-    oldLayout = rhs.oldLayout;
-    newLayout = rhs.newLayout;
-    srcQueueFamilyIndex = rhs.srcQueueFamilyIndex;
-    dstQueueFamilyIndex = rhs.dstQueueFamilyIndex;
-    image = rhs.image;
-    subresourceRange = rhs.subresourceRange;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageMemoryBarrier ) );
       return *this;
     }
 
@@ -31913,6 +32053,8 @@
     : dstSet( dstSet_ ), dstBinding( dstBinding_ ), dstArrayElement( dstArrayElement_ ), descriptorCount( descriptorCount_ ), descriptorType( descriptorType_ ), pImageInfo( pImageInfo_ ), pBufferInfo( pBufferInfo_ ), pTexelBufferView( pTexelBufferView_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR WriteDescriptorSet( WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -31942,16 +32084,7 @@
 
     WriteDescriptorSet & operator=( WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    dstSet = rhs.dstSet;
-    dstBinding = rhs.dstBinding;
-    dstArrayElement = rhs.dstArrayElement;
-    descriptorCount = rhs.descriptorCount;
-    descriptorType = rhs.descriptorType;
-    pImageInfo = rhs.pImageInfo;
-    pBufferInfo = rhs.pBufferInfo;
-    pTexelBufferView = rhs.pTexelBufferView;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( WriteDescriptorSet ) );
       return *this;
     }
 
@@ -32305,6 +32438,8 @@
     : srcSubresource( srcSubresource_ ), srcOffset( srcOffset_ ), dstSubresource( dstSubresource_ ), dstOffset( dstOffset_ ), extent( extent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageResolve( ImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageResolve( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -32317,6 +32452,12 @@
       return *this;
     }
 
+    ImageResolve & operator=( ImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageResolve ) );
+      return *this;
+    }
+
     ImageResolve & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT
     {
       srcSubresource = srcSubresource_;
@@ -32400,6 +32541,8 @@
     : marker( marker_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -32414,9 +32557,7 @@
 
     PerformanceMarkerInfoINTEL & operator=( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    marker = rhs.marker;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PerformanceMarkerInfoINTEL ) );
       return *this;
     }
 
@@ -32487,6 +32628,8 @@
     : type( type_ ), enable( enable_ ), parameter( parameter_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -32501,11 +32644,7 @@
 
     PerformanceOverrideInfoINTEL & operator=( PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    type = rhs.type;
-    enable = rhs.enable;
-    parameter = rhs.parameter;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PerformanceOverrideInfoINTEL ) );
       return *this;
     }
 
@@ -32592,6 +32731,8 @@
     : marker( marker_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -32606,9 +32747,7 @@
 
     PerformanceStreamMarkerInfoINTEL & operator=( PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    marker = rhs.marker;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PerformanceStreamMarkerInfoINTEL ) );
       return *this;
     }
 
@@ -32678,6 +32817,8 @@
     : x( x_ ), y( y_ ), width( width_ ), height( height_ ), minDepth( minDepth_ ), maxDepth( maxDepth_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Viewport( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -32690,6 +32831,12 @@
       return *this;
     }
 
+    Viewport & operator=( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Viewport ) );
+      return *this;
+    }
+
     Viewport & setX( float x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -32780,6 +32927,8 @@
     : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ ), pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( ShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -32798,6 +32947,12 @@
       return *this;
     }
 
+    ShadingRatePaletteNV & operator=( ShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ShadingRatePaletteNV ) );
+      return *this;
+    }
+
     ShadingRatePaletteNV & setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ ) VULKAN_HPP_NOEXCEPT
     {
       shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_;
@@ -32865,6 +33020,8 @@
     : xcoeff( xcoeff_ ), ycoeff( ycoeff_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ViewportWScalingNV( ViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ViewportWScalingNV( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -32877,6 +33034,12 @@
       return *this;
     }
 
+    ViewportWScalingNV & operator=( ViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ViewportWScalingNV ) );
+      return *this;
+    }
+
     ViewportWScalingNV & setXcoeff( float xcoeff_ ) VULKAN_HPP_NOEXCEPT
     {
       xcoeff = xcoeff_;
@@ -32936,6 +33099,8 @@
     : buffer( buffer_ ), offset( offset_ ), stride( stride_ ), size( size_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR StridedBufferRegionKHR( StridedBufferRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     StridedBufferRegionKHR( VkStridedBufferRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -32955,6 +33120,12 @@
       return *this;
     }
 
+    StridedBufferRegionKHR & operator=( StridedBufferRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( StridedBufferRegionKHR ) );
+      return *this;
+    }
+
     StridedBufferRegionKHR & setBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer_ ) VULKAN_HPP_NOEXCEPT
     {
       buffer = buffer_;
@@ -34064,6 +34235,8 @@
     : allocationSize( allocationSize_ ), memoryTypeIndex( memoryTypeIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -34078,10 +34251,7 @@
 
     MemoryAllocateInfo & operator=( MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    allocationSize = rhs.allocationSize;
-    memoryTypeIndex = rhs.memoryTypeIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryAllocateInfo ) );
       return *this;
     }
 
@@ -34260,6 +34430,8 @@
     : flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR EventCreateInfo( EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -34274,9 +34446,7 @@
 
     EventCreateInfo & operator=( EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( EventCreateInfo ) );
       return *this;
     }
 
@@ -34347,6 +34517,8 @@
     : flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FenceCreateInfo( FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -34361,9 +34533,7 @@
 
     FenceCreateInfo & operator=( FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FenceCreateInfo ) );
       return *this;
     }
 
@@ -34434,6 +34604,8 @@
     : flags( flags_ ), renderPass( renderPass_ ), attachmentCount( attachmentCount_ ), pAttachments( pAttachments_ ), width( width_ ), height( height_ ), layers( layers_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -34454,15 +34626,7 @@
 
     FramebufferCreateInfo & operator=( FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    renderPass = rhs.renderPass;
-    attachmentCount = rhs.attachmentCount;
-    pAttachments = rhs.pAttachments;
-    width = rhs.width;
-    height = rhs.height;
-    layers = rhs.layers;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FramebufferCreateInfo ) );
       return *this;
     }
 
@@ -34589,6 +34753,8 @@
     : binding( binding_ ), stride( stride_ ), inputRate( inputRate_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( VertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -34601,6 +34767,12 @@
       return *this;
     }
 
+    VertexInputBindingDescription & operator=( VertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( VertexInputBindingDescription ) );
+      return *this;
+    }
+
     VertexInputBindingDescription & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
     {
       binding = binding_;
@@ -34667,6 +34839,8 @@
     : location( location_ ), binding( binding_ ), format( format_ ), offset( offset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( VertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -34679,6 +34853,12 @@
       return *this;
     }
 
+    VertexInputAttributeDescription & operator=( VertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( VertexInputAttributeDescription ) );
+      return *this;
+    }
+
     VertexInputAttributeDescription & setLocation( uint32_t location_ ) VULKAN_HPP_NOEXCEPT
     {
       location = location_;
@@ -34754,6 +34934,8 @@
     : flags( flags_ ), vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ), pVertexBindingDescriptions( pVertexBindingDescriptions_ ), vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ), pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -34774,13 +34956,7 @@
 
     PipelineVertexInputStateCreateInfo & operator=( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    vertexBindingDescriptionCount = rhs.vertexBindingDescriptionCount;
-    pVertexBindingDescriptions = rhs.pVertexBindingDescriptions;
-    vertexAttributeDescriptionCount = rhs.vertexAttributeDescriptionCount;
-    pVertexAttributeDescriptions = rhs.pVertexAttributeDescriptions;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
       return *this;
     }
 
@@ -34901,6 +35077,8 @@
     : flags( flags_ ), topology( topology_ ), primitiveRestartEnable( primitiveRestartEnable_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -34915,11 +35093,7 @@
 
     PipelineInputAssemblyStateCreateInfo & operator=( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    topology = rhs.topology;
-    primitiveRestartEnable = rhs.primitiveRestartEnable;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
       return *this;
     }
 
@@ -35006,6 +35180,8 @@
     : flags( flags_ ), patchControlPoints( patchControlPoints_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -35020,10 +35196,7 @@
 
     PipelineTessellationStateCreateInfo & operator=( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    patchControlPoints = rhs.patchControlPoints;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
       return *this;
     }
 
@@ -35102,6 +35275,8 @@
     : flags( flags_ ), viewportCount( viewportCount_ ), pViewports( pViewports_ ), scissorCount( scissorCount_ ), pScissors( pScissors_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -35122,13 +35297,7 @@
 
     PipelineViewportStateCreateInfo & operator=( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    viewportCount = rhs.viewportCount;
-    pViewports = rhs.pViewports;
-    scissorCount = rhs.scissorCount;
-    pScissors = rhs.pScissors;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineViewportStateCreateInfo ) );
       return *this;
     }
 
@@ -35249,6 +35418,8 @@
     : flags( flags_ ), depthClampEnable( depthClampEnable_ ), rasterizerDiscardEnable( rasterizerDiscardEnable_ ), polygonMode( polygonMode_ ), cullMode( cullMode_ ), frontFace( frontFace_ ), depthBiasEnable( depthBiasEnable_ ), depthBiasConstantFactor( depthBiasConstantFactor_ ), depthBiasClamp( depthBiasClamp_ ), depthBiasSlopeFactor( depthBiasSlopeFactor_ ), lineWidth( lineWidth_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -35263,19 +35434,7 @@
 
     PipelineRasterizationStateCreateInfo & operator=( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    depthClampEnable = rhs.depthClampEnable;
-    rasterizerDiscardEnable = rhs.rasterizerDiscardEnable;
-    polygonMode = rhs.polygonMode;
-    cullMode = rhs.cullMode;
-    frontFace = rhs.frontFace;
-    depthBiasEnable = rhs.depthBiasEnable;
-    depthBiasConstantFactor = rhs.depthBiasConstantFactor;
-    depthBiasClamp = rhs.depthBiasClamp;
-    depthBiasSlopeFactor = rhs.depthBiasSlopeFactor;
-    lineWidth = rhs.lineWidth;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
       return *this;
     }
 
@@ -35426,6 +35585,8 @@
     : flags( flags_ ), rasterizationSamples( rasterizationSamples_ ), sampleShadingEnable( sampleShadingEnable_ ), minSampleShading( minSampleShading_ ), pSampleMask( pSampleMask_ ), alphaToCoverageEnable( alphaToCoverageEnable_ ), alphaToOneEnable( alphaToOneEnable_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -35440,15 +35601,7 @@
 
     PipelineMultisampleStateCreateInfo & operator=( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    rasterizationSamples = rhs.rasterizationSamples;
-    sampleShadingEnable = rhs.sampleShadingEnable;
-    minSampleShading = rhs.minSampleShading;
-    pSampleMask = rhs.pSampleMask;
-    alphaToCoverageEnable = rhs.alphaToCoverageEnable;
-    alphaToOneEnable = rhs.alphaToOneEnable;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
       return *this;
     }
 
@@ -35566,6 +35719,8 @@
     : failOp( failOp_ ), passOp( passOp_ ), depthFailOp( depthFailOp_ ), compareOp( compareOp_ ), compareMask( compareMask_ ), writeMask( writeMask_ ), reference( reference_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR StencilOpState( StencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -35578,6 +35733,12 @@
       return *this;
     }
 
+    StencilOpState & operator=( StencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( StencilOpState ) );
+      return *this;
+    }
+
     StencilOpState & setFailOp( VULKAN_HPP_NAMESPACE::StencilOp failOp_ ) VULKAN_HPP_NOEXCEPT
     {
       failOp = failOp_;
@@ -35677,6 +35838,8 @@
     : flags( flags_ ), depthTestEnable( depthTestEnable_ ), depthWriteEnable( depthWriteEnable_ ), depthCompareOp( depthCompareOp_ ), depthBoundsTestEnable( depthBoundsTestEnable_ ), stencilTestEnable( stencilTestEnable_ ), front( front_ ), back( back_ ), minDepthBounds( minDepthBounds_ ), maxDepthBounds( maxDepthBounds_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -35691,18 +35854,7 @@
 
     PipelineDepthStencilStateCreateInfo & operator=( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    depthTestEnable = rhs.depthTestEnable;
-    depthWriteEnable = rhs.depthWriteEnable;
-    depthCompareOp = rhs.depthCompareOp;
-    depthBoundsTestEnable = rhs.depthBoundsTestEnable;
-    stencilTestEnable = rhs.stencilTestEnable;
-    front = rhs.front;
-    back = rhs.back;
-    minDepthBounds = rhs.minDepthBounds;
-    maxDepthBounds = rhs.maxDepthBounds;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
       return *this;
     }
 
@@ -35844,6 +35996,8 @@
     : blendEnable( blendEnable_ ), srcColorBlendFactor( srcColorBlendFactor_ ), dstColorBlendFactor( dstColorBlendFactor_ ), colorBlendOp( colorBlendOp_ ), srcAlphaBlendFactor( srcAlphaBlendFactor_ ), dstAlphaBlendFactor( dstAlphaBlendFactor_ ), alphaBlendOp( alphaBlendOp_ ), colorWriteMask( colorWriteMask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( PipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -35856,6 +36010,12 @@
       return *this;
     }
 
+    PipelineColorBlendAttachmentState & operator=( PipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineColorBlendAttachmentState ) );
+      return *this;
+    }
+
     PipelineColorBlendAttachmentState & setBlendEnable( VULKAN_HPP_NAMESPACE::Bool32 blendEnable_ ) VULKAN_HPP_NOEXCEPT
     {
       blendEnable = blendEnable_;
@@ -35963,6 +36123,8 @@
     : flags( flags_ ), logicOpEnable( logicOpEnable_ ), logicOp( logicOp_ ), attachmentCount( attachmentCount_ ), pAttachments( pAttachments_ ), blendConstants( blendConstants_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -35983,14 +36145,7 @@
 
     PipelineColorBlendStateCreateInfo & operator=( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    logicOpEnable = rhs.logicOpEnable;
-    logicOp = rhs.logicOp;
-    attachmentCount = rhs.attachmentCount;
-    pAttachments = rhs.pAttachments;
-    blendConstants = rhs.blendConstants;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
       return *this;
     }
 
@@ -36110,6 +36265,8 @@
     : flags( flags_ ), dynamicStateCount( dynamicStateCount_ ), pDynamicStates( pDynamicStates_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -36130,11 +36287,7 @@
 
     PipelineDynamicStateCreateInfo & operator=( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    dynamicStateCount = rhs.dynamicStateCount;
-    pDynamicStates = rhs.pDynamicStates;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
       return *this;
     }
 
@@ -36230,6 +36383,8 @@
     : 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_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -36250,25 +36405,7 @@
 
     GraphicsPipelineCreateInfo & operator=( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    stageCount = rhs.stageCount;
-    pStages = rhs.pStages;
-    pVertexInputState = rhs.pVertexInputState;
-    pInputAssemblyState = rhs.pInputAssemblyState;
-    pTessellationState = rhs.pTessellationState;
-    pViewportState = rhs.pViewportState;
-    pRasterizationState = rhs.pRasterizationState;
-    pMultisampleState = rhs.pMultisampleState;
-    pDepthStencilState = rhs.pDepthStencilState;
-    pColorBlendState = rhs.pColorBlendState;
-    pDynamicState = rhs.pDynamicState;
-    layout = rhs.layout;
-    renderPass = rhs.renderPass;
-    subpass = rhs.subpass;
-    basePipelineHandle = rhs.basePipelineHandle;
-    basePipelineIndex = rhs.basePipelineIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GraphicsPipelineCreateInfo ) );
       return *this;
     }
 
@@ -36476,6 +36613,8 @@
     : 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_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageCreateInfo( ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -36496,21 +36635,7 @@
 
     ImageCreateInfo & operator=( ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    imageType = rhs.imageType;
-    format = rhs.format;
-    extent = rhs.extent;
-    mipLevels = rhs.mipLevels;
-    arrayLayers = rhs.arrayLayers;
-    samples = rhs.samples;
-    tiling = rhs.tiling;
-    usage = rhs.usage;
-    sharingMode = rhs.sharingMode;
-    queueFamilyIndexCount = rhs.queueFamilyIndexCount;
-    pQueueFamilyIndices = rhs.pQueueFamilyIndices;
-    initialLayout = rhs.initialLayout;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageCreateInfo ) );
       return *this;
     }
 
@@ -36686,6 +36811,8 @@
     : flags( flags_ ), image( image_ ), viewType( viewType_ ), format( format_ ), components( components_ ), subresourceRange( subresourceRange_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -36700,14 +36827,7 @@
 
     ImageViewCreateInfo & operator=( ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    image = rhs.image;
-    viewType = rhs.viewType;
-    format = rhs.format;
-    components = rhs.components;
-    subresourceRange = rhs.subresourceRange;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageViewCreateInfo ) );
       return *this;
     }
 
@@ -36818,6 +36938,8 @@
     : tokenType( tokenType_ ), stream( stream_ ), offset( offset_ ), vertexBindingUnit( vertexBindingUnit_ ), vertexDynamicStride( vertexDynamicStride_ ), pushconstantPipelineLayout( pushconstantPipelineLayout_ ), pushconstantShaderStageFlags( pushconstantShaderStageFlags_ ), pushconstantOffset( pushconstantOffset_ ), pushconstantSize( pushconstantSize_ ), indirectStateFlags( indirectStateFlags_ ), indexTypeCount( indexTypeCount_ ), pIndexTypes( pIndexTypes_ ), pIndexTypeValues( pIndexTypeValues_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( IndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     IndirectCommandsLayoutTokenNV( VkIndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -36847,21 +36969,7 @@
 
     IndirectCommandsLayoutTokenNV & operator=( IndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    tokenType = rhs.tokenType;
-    stream = rhs.stream;
-    offset = rhs.offset;
-    vertexBindingUnit = rhs.vertexBindingUnit;
-    vertexDynamicStride = rhs.vertexDynamicStride;
-    pushconstantPipelineLayout = rhs.pushconstantPipelineLayout;
-    pushconstantShaderStageFlags = rhs.pushconstantShaderStageFlags;
-    pushconstantOffset = rhs.pushconstantOffset;
-    pushconstantSize = rhs.pushconstantSize;
-    indirectStateFlags = rhs.indirectStateFlags;
-    indexTypeCount = rhs.indexTypeCount;
-    pIndexTypes = rhs.pIndexTypes;
-    pIndexTypeValues = rhs.pIndexTypeValues;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( IndirectCommandsLayoutTokenNV ) );
       return *this;
     }
 
@@ -37046,6 +37154,8 @@
     : flags( flags_ ), pipelineBindPoint( pipelineBindPoint_ ), tokenCount( tokenCount_ ), pTokens( pTokens_ ), streamCount( streamCount_ ), pStreamStrides( pStreamStrides_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( IndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     IndirectCommandsLayoutCreateInfoNV( VkIndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -37066,14 +37176,7 @@
 
     IndirectCommandsLayoutCreateInfoNV & operator=( IndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pipelineBindPoint = rhs.pipelineBindPoint;
-    tokenCount = rhs.tokenCount;
-    pTokens = rhs.pTokens;
-    streamCount = rhs.streamCount;
-    pStreamStrides = rhs.pStreamStrides;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( IndirectCommandsLayoutCreateInfoNV ) );
       return *this;
     }
 
@@ -37202,6 +37305,8 @@
     : flags( flags_ ), initialDataSize( initialDataSize_ ), pInitialData( pInitialData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -37223,11 +37328,7 @@
 
     PipelineCacheCreateInfo & operator=( PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    initialDataSize = rhs.initialDataSize;
-    pInitialData = rhs.pInitialData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineCacheCreateInfo ) );
       return *this;
     }
 
@@ -37323,6 +37424,8 @@
     : stageFlags( stageFlags_ ), offset( offset_ ), size( size_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PushConstantRange( PushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PushConstantRange( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -37335,6 +37438,12 @@
       return *this;
     }
 
+    PushConstantRange & operator=( PushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PushConstantRange ) );
+      return *this;
+    }
+
     PushConstantRange & setStageFlags( VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags_ ) VULKAN_HPP_NOEXCEPT
     {
       stageFlags = stageFlags_;
@@ -37402,6 +37511,8 @@
     : flags( flags_ ), setLayoutCount( setLayoutCount_ ), pSetLayouts( pSetLayouts_ ), pushConstantRangeCount( pushConstantRangeCount_ ), pPushConstantRanges( pPushConstantRanges_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -37422,13 +37533,7 @@
 
     PipelineLayoutCreateInfo & operator=( PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    setLayoutCount = rhs.setLayoutCount;
-    pSetLayouts = rhs.pSetLayouts;
-    pushConstantRangeCount = rhs.pushConstantRangeCount;
-    pPushConstantRanges = rhs.pPushConstantRanges;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineLayoutCreateInfo ) );
       return *this;
     }
 
@@ -37549,6 +37654,8 @@
     : flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PrivateDataSlotCreateInfoEXT( PrivateDataSlotCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PrivateDataSlotCreateInfoEXT( VkPrivateDataSlotCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -37563,9 +37670,7 @@
 
     PrivateDataSlotCreateInfoEXT & operator=( PrivateDataSlotCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PrivateDataSlotCreateInfoEXT ) );
       return *this;
     }
 
@@ -37730,6 +37835,8 @@
     : flags( flags_ ), queryType( queryType_ ), queryCount( queryCount_ ), pipelineStatistics( pipelineStatistics_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -37744,12 +37851,7 @@
 
     QueryPoolCreateInfo & operator=( QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    queryType = rhs.queryType;
-    queryCount = rhs.queryCount;
-    pipelineStatistics = rhs.pipelineStatistics;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( QueryPoolCreateInfo ) );
       return *this;
     }
 
@@ -37845,6 +37947,8 @@
     : type( type_ ), generalShader( generalShader_ ), closestHitShader( closestHitShader_ ), anyHitShader( anyHitShader_ ), intersectionShader( intersectionShader_ ), pShaderGroupCaptureReplayHandle( pShaderGroupCaptureReplayHandle_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( RayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RayTracingShaderGroupCreateInfoKHR( VkRayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -37859,14 +37963,7 @@
 
     RayTracingShaderGroupCreateInfoKHR & operator=( RayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    type = rhs.type;
-    generalShader = rhs.generalShader;
-    closestHitShader = rhs.closestHitShader;
-    anyHitShader = rhs.anyHitShader;
-    intersectionShader = rhs.intersectionShader;
-    pShaderGroupCaptureReplayHandle = rhs.pShaderGroupCaptureReplayHandle;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RayTracingShaderGroupCreateInfoKHR ) );
       return *this;
     }
 
@@ -37979,6 +38076,8 @@
     : libraryCount( libraryCount_ ), pLibraries( pLibraries_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineLibraryCreateInfoKHR( PipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineLibraryCreateInfoKHR( VkPipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -37999,10 +38098,7 @@
 
     PipelineLibraryCreateInfoKHR & operator=( PipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    libraryCount = rhs.libraryCount;
-    pLibraries = rhs.pLibraries;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineLibraryCreateInfoKHR ) );
       return *this;
     }
 
@@ -38092,6 +38188,8 @@
     : maxPayloadSize( maxPayloadSize_ ), maxAttributeSize( maxAttributeSize_ ), maxCallableSize( maxCallableSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RayTracingPipelineInterfaceCreateInfoKHR( VkRayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -38106,11 +38204,7 @@
 
     RayTracingPipelineInterfaceCreateInfoKHR & operator=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxPayloadSize = rhs.maxPayloadSize;
-    maxAttributeSize = rhs.maxAttributeSize;
-    maxCallableSize = rhs.maxCallableSize;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RayTracingPipelineInterfaceCreateInfoKHR ) );
       return *this;
     }
 
@@ -38199,6 +38293,8 @@
     : flags( flags_ ), stageCount( stageCount_ ), pStages( pStages_ ), groupCount( groupCount_ ), pGroups( pGroups_ ), maxRecursionDepth( maxRecursionDepth_ ), libraries( libraries_ ), pLibraryInterface( pLibraryInterface_ ), layout( layout_ ), basePipelineHandle( basePipelineHandle_ ), basePipelineIndex( basePipelineIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( RayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RayTracingPipelineCreateInfoKHR( VkRayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -38219,19 +38315,7 @@
 
     RayTracingPipelineCreateInfoKHR & operator=( RayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    stageCount = rhs.stageCount;
-    pStages = rhs.pStages;
-    groupCount = rhs.groupCount;
-    pGroups = rhs.pGroups;
-    maxRecursionDepth = rhs.maxRecursionDepth;
-    libraries = rhs.libraries;
-    pLibraryInterface = rhs.pLibraryInterface;
-    layout = rhs.layout;
-    basePipelineHandle = rhs.basePipelineHandle;
-    basePipelineIndex = rhs.basePipelineIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RayTracingPipelineCreateInfoKHR ) );
       return *this;
     }
 
@@ -38401,6 +38485,8 @@
     : type( type_ ), generalShader( generalShader_ ), closestHitShader( closestHitShader_ ), anyHitShader( anyHitShader_ ), intersectionShader( intersectionShader_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -38415,13 +38501,7 @@
 
     RayTracingShaderGroupCreateInfoNV & operator=( RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    type = rhs.type;
-    generalShader = rhs.generalShader;
-    closestHitShader = rhs.closestHitShader;
-    anyHitShader = rhs.anyHitShader;
-    intersectionShader = rhs.intersectionShader;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
       return *this;
     }
 
@@ -38524,6 +38604,8 @@
     : flags( flags_ ), stageCount( stageCount_ ), pStages( pStages_ ), groupCount( groupCount_ ), pGroups( pGroups_ ), maxRecursionDepth( maxRecursionDepth_ ), layout( layout_ ), basePipelineHandle( basePipelineHandle_ ), basePipelineIndex( basePipelineIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -38544,17 +38626,7 @@
 
     RayTracingPipelineCreateInfoNV & operator=( RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    stageCount = rhs.stageCount;
-    pStages = rhs.pStages;
-    groupCount = rhs.groupCount;
-    pGroups = rhs.pGroups;
-    maxRecursionDepth = rhs.maxRecursionDepth;
-    layout = rhs.layout;
-    basePipelineHandle = rhs.basePipelineHandle;
-    basePipelineIndex = rhs.basePipelineIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
       return *this;
     }
 
@@ -38706,6 +38778,8 @@
     : flags( flags_ ), pipelineBindPoint( pipelineBindPoint_ ), inputAttachmentCount( inputAttachmentCount_ ), pInputAttachments( pInputAttachments_ ), colorAttachmentCount( colorAttachmentCount_ ), pColorAttachments( pColorAttachments_ ), pResolveAttachments( pResolveAttachments_ ), pDepthStencilAttachment( pDepthStencilAttachment_ ), preserveAttachmentCount( preserveAttachmentCount_ ), pPreserveAttachments( pPreserveAttachments_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubpassDescription( SubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -38733,6 +38807,12 @@
       return *this;
     }
 
+    SubpassDescription & operator=( SubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubpassDescription ) );
+      return *this;
+    }
+
     SubpassDescription & setFlags( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ ) VULKAN_HPP_NOEXCEPT
     {
       flags = flags_;
@@ -38891,6 +38971,8 @@
     : srcSubpass( srcSubpass_ ), dstSubpass( dstSubpass_ ), srcStageMask( srcStageMask_ ), dstStageMask( dstStageMask_ ), srcAccessMask( srcAccessMask_ ), dstAccessMask( dstAccessMask_ ), dependencyFlags( dependencyFlags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubpassDependency( SubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -38903,6 +38985,12 @@
       return *this;
     }
 
+    SubpassDependency & operator=( SubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubpassDependency ) );
+      return *this;
+    }
+
     SubpassDependency & setSrcSubpass( uint32_t srcSubpass_ ) VULKAN_HPP_NOEXCEPT
     {
       srcSubpass = srcSubpass_;
@@ -39002,6 +39090,8 @@
     : flags( flags_ ), attachmentCount( attachmentCount_ ), pAttachments( pAttachments_ ), subpassCount( subpassCount_ ), pSubpasses( pSubpasses_ ), dependencyCount( dependencyCount_ ), pDependencies( pDependencies_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -39022,15 +39112,7 @@
 
     RenderPassCreateInfo & operator=( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    attachmentCount = rhs.attachmentCount;
-    pAttachments = rhs.pAttachments;
-    subpassCount = rhs.subpassCount;
-    pSubpasses = rhs.pSubpasses;
-    dependencyCount = rhs.dependencyCount;
-    pDependencies = rhs.pDependencies;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassCreateInfo ) );
       return *this;
     }
 
@@ -39176,6 +39258,8 @@
     : flags( flags_ ), pipelineBindPoint( pipelineBindPoint_ ), viewMask( viewMask_ ), inputAttachmentCount( inputAttachmentCount_ ), pInputAttachments( pInputAttachments_ ), colorAttachmentCount( colorAttachmentCount_ ), pColorAttachments( pColorAttachments_ ), pResolveAttachments( pResolveAttachments_ ), pDepthStencilAttachment( pDepthStencilAttachment_ ), preserveAttachmentCount( preserveAttachmentCount_ ), pPreserveAttachments( pPreserveAttachments_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubpassDescription2( SubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubpassDescription2( VkSubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -39205,19 +39289,7 @@
 
     SubpassDescription2 & operator=( SubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pipelineBindPoint = rhs.pipelineBindPoint;
-    viewMask = rhs.viewMask;
-    inputAttachmentCount = rhs.inputAttachmentCount;
-    pInputAttachments = rhs.pInputAttachments;
-    colorAttachmentCount = rhs.colorAttachmentCount;
-    pColorAttachments = rhs.pColorAttachments;
-    pResolveAttachments = rhs.pResolveAttachments;
-    pDepthStencilAttachment = rhs.pDepthStencilAttachment;
-    preserveAttachmentCount = rhs.preserveAttachmentCount;
-    pPreserveAttachments = rhs.pPreserveAttachments;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubpassDescription2 ) );
       return *this;
     }
 
@@ -39405,6 +39477,8 @@
     : srcSubpass( srcSubpass_ ), dstSubpass( dstSubpass_ ), srcStageMask( srcStageMask_ ), dstStageMask( dstStageMask_ ), srcAccessMask( srcAccessMask_ ), dstAccessMask( dstAccessMask_ ), dependencyFlags( dependencyFlags_ ), viewOffset( viewOffset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubpassDependency2( SubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubpassDependency2( VkSubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -39419,16 +39493,7 @@
 
     SubpassDependency2 & operator=( SubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    srcSubpass = rhs.srcSubpass;
-    dstSubpass = rhs.dstSubpass;
-    srcStageMask = rhs.srcStageMask;
-    dstStageMask = rhs.dstStageMask;
-    srcAccessMask = rhs.srcAccessMask;
-    dstAccessMask = rhs.dstAccessMask;
-    dependencyFlags = rhs.dependencyFlags;
-    viewOffset = rhs.viewOffset;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubpassDependency2 ) );
       return *this;
     }
 
@@ -39556,6 +39621,8 @@
     : flags( flags_ ), attachmentCount( attachmentCount_ ), pAttachments( pAttachments_ ), subpassCount( subpassCount_ ), pSubpasses( pSubpasses_ ), dependencyCount( dependencyCount_ ), pDependencies( pDependencies_ ), correlatedViewMaskCount( correlatedViewMaskCount_ ), pCorrelatedViewMasks( pCorrelatedViewMasks_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( RenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassCreateInfo2( VkRenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -39576,17 +39643,7 @@
 
     RenderPassCreateInfo2 & operator=( RenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    attachmentCount = rhs.attachmentCount;
-    pAttachments = rhs.pAttachments;
-    subpassCount = rhs.subpassCount;
-    pSubpasses = rhs.pSubpasses;
-    dependencyCount = rhs.dependencyCount;
-    pDependencies = rhs.pDependencies;
-    correlatedViewMaskCount = rhs.correlatedViewMaskCount;
-    pCorrelatedViewMasks = rhs.pCorrelatedViewMasks;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassCreateInfo2 ) );
       return *this;
     }
 
@@ -39758,6 +39815,8 @@
     : 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_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SamplerCreateInfo( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -39772,24 +39831,7 @@
 
     SamplerCreateInfo & operator=( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    magFilter = rhs.magFilter;
-    minFilter = rhs.minFilter;
-    mipmapMode = rhs.mipmapMode;
-    addressModeU = rhs.addressModeU;
-    addressModeV = rhs.addressModeV;
-    addressModeW = rhs.addressModeW;
-    mipLodBias = rhs.mipLodBias;
-    anisotropyEnable = rhs.anisotropyEnable;
-    maxAnisotropy = rhs.maxAnisotropy;
-    compareEnable = rhs.compareEnable;
-    compareOp = rhs.compareOp;
-    minLod = rhs.minLod;
-    maxLod = rhs.maxLod;
-    borderColor = rhs.borderColor;
-    unnormalizedCoordinates = rhs.unnormalizedCoordinates;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SamplerCreateInfo ) );
       return *this;
     }
 
@@ -39980,6 +40022,8 @@
     : format( format_ ), ycbcrModel( ycbcrModel_ ), ycbcrRange( ycbcrRange_ ), components( components_ ), xChromaOffset( xChromaOffset_ ), yChromaOffset( yChromaOffset_ ), chromaFilter( chromaFilter_ ), forceExplicitReconstruction( forceExplicitReconstruction_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -39994,16 +40038,7 @@
 
     SamplerYcbcrConversionCreateInfo & operator=( SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    format = rhs.format;
-    ycbcrModel = rhs.ycbcrModel;
-    ycbcrRange = rhs.ycbcrRange;
-    components = rhs.components;
-    xChromaOffset = rhs.xChromaOffset;
-    yChromaOffset = rhs.yChromaOffset;
-    chromaFilter = rhs.chromaFilter;
-    forceExplicitReconstruction = rhs.forceExplicitReconstruction;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
       return *this;
     }
 
@@ -40232,6 +40267,8 @@
     : flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -40246,9 +40283,7 @@
 
     SemaphoreCreateInfo & operator=( SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SemaphoreCreateInfo ) );
       return *this;
     }
 
@@ -40319,6 +40354,8 @@
     : flags( flags_ ), codeSize( codeSize_ ), pCode( pCode_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -40339,11 +40376,7 @@
 
     ShaderModuleCreateInfo & operator=( ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    codeSize = rhs.codeSize;
-    pCode = rhs.pCode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ShaderModuleCreateInfo ) );
       return *this;
     }
 
@@ -40539,6 +40572,8 @@
     : 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_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -40559,24 +40594,7 @@
 
     SwapchainCreateInfoKHR & operator=( SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    surface = rhs.surface;
-    minImageCount = rhs.minImageCount;
-    imageFormat = rhs.imageFormat;
-    imageColorSpace = rhs.imageColorSpace;
-    imageExtent = rhs.imageExtent;
-    imageArrayLayers = rhs.imageArrayLayers;
-    imageUsage = rhs.imageUsage;
-    imageSharingMode = rhs.imageSharingMode;
-    queueFamilyIndexCount = rhs.queueFamilyIndexCount;
-    pQueueFamilyIndices = rhs.pQueueFamilyIndices;
-    preTransform = rhs.preTransform;
-    compositeAlpha = rhs.compositeAlpha;
-    presentMode = rhs.presentMode;
-    clipped = rhs.clipped;
-    oldSwapchain = rhs.oldSwapchain;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SwapchainCreateInfoKHR ) );
       return *this;
     }
 
@@ -40776,6 +40794,8 @@
     : flags( flags_ ), initialDataSize( initialDataSize_ ), pInitialData( pInitialData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -40797,11 +40817,7 @@
 
     ValidationCacheCreateInfoEXT & operator=( ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    initialDataSize = rhs.initialDataSize;
-    pInitialData = rhs.pInitialData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
       return *this;
     }
 
@@ -40998,6 +41014,8 @@
     : powerState( powerState_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41012,9 +41030,7 @@
 
     DisplayPowerInfoEXT & operator=( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    powerState = rhs.powerState;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayPowerInfoEXT ) );
       return *this;
     }
 
@@ -41085,6 +41101,8 @@
     : memory( memory_ ), offset( offset_ ), size( size_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MappedMemoryRange( MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41099,11 +41117,7 @@
 
     MappedMemoryRange & operator=( MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memory = rhs.memory;
-    offset = rhs.offset;
-    size = rhs.size;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MappedMemoryRange ) );
       return *this;
     }
 
@@ -41189,6 +41203,8 @@
     : size( size_ ), alignment( alignment_ ), memoryTypeBits( memoryTypeBits_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryRequirements( MemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryRequirements( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41201,6 +41217,12 @@
       return *this;
     }
 
+    MemoryRequirements & operator=( MemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryRequirements ) );
+      return *this;
+    }
+
 
     operator VkMemoryRequirements const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -41250,6 +41272,8 @@
     : memoryRequirements( memoryRequirements_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryRequirements2( MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41264,9 +41288,7 @@
 
     MemoryRequirements2 & operator=( MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memoryRequirements = rhs.memoryRequirements;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryRequirements2 ) );
       return *this;
     }
 
@@ -41326,6 +41348,8 @@
     : presentMask( presentMask_ ), modes( modes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41340,10 +41364,7 @@
 
     DeviceGroupPresentCapabilitiesKHR & operator=( DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    presentMask = rhs.presentMask;
-    modes = rhs.modes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceGroupPresentCapabilitiesKHR ) );
       return *this;
     }
 
@@ -41404,6 +41425,8 @@
     : surface( surface_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41418,9 +41441,7 @@
 
     PhysicalDeviceSurfaceInfo2KHR & operator=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    surface = rhs.surface;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
       return *this;
     }
 
@@ -41491,6 +41512,8 @@
     : memory( memory_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceMemoryOpaqueCaptureAddressInfo( VkDeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41505,9 +41528,7 @@
 
     DeviceMemoryOpaqueCaptureAddressInfo & operator=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memory = rhs.memory;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceMemoryOpaqueCaptureAddressInfo ) );
       return *this;
     }
 
@@ -41579,6 +41600,8 @@
     : waitSemaphoreCount( waitSemaphoreCount_ ), pWaitSemaphores( pWaitSemaphores_ ), swapchainCount( swapchainCount_ ), pSwapchains( pSwapchains_ ), pImageIndices( pImageIndices_ ), pResults( pResults_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PresentInfoKHR( PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41618,14 +41641,7 @@
 
     PresentInfoKHR & operator=( PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    waitSemaphoreCount = rhs.waitSemaphoreCount;
-    pWaitSemaphores = rhs.pWaitSemaphores;
-    swapchainCount = rhs.swapchainCount;
-    pSwapchains = rhs.pSwapchains;
-    pImageIndices = rhs.pImageIndices;
-    pResults = rhs.pResults;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PresentInfoKHR ) );
       return *this;
     }
 
@@ -41772,6 +41788,8 @@
     : waitSemaphoreCount( waitSemaphoreCount_ ), pWaitSemaphores( pWaitSemaphores_ ), pWaitDstStageMask( pWaitDstStageMask_ ), commandBufferCount( commandBufferCount_ ), pCommandBuffers( pCommandBuffers_ ), signalSemaphoreCount( signalSemaphoreCount_ ), pSignalSemaphores( pSignalSemaphores_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubmitInfo( SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -41801,15 +41819,7 @@
 
     SubmitInfo & operator=( SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    waitSemaphoreCount = rhs.waitSemaphoreCount;
-    pWaitSemaphores = rhs.pWaitSemaphores;
-    pWaitDstStageMask = rhs.pWaitDstStageMask;
-    commandBufferCount = rhs.commandBufferCount;
-    pCommandBuffers = rhs.pCommandBuffers;
-    signalSemaphoreCount = rhs.signalSemaphoreCount;
-    pSignalSemaphores = rhs.pSignalSemaphores;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubmitInfo ) );
       return *this;
     }
 
@@ -42132,6 +42142,8 @@
     : flags( flags_ ), queueFamilyIndex( queueFamilyIndex_ ), queueIndex( queueIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42146,11 +42158,7 @@
 
     DeviceQueueInfo2 & operator=( DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    queueFamilyIndex = rhs.queueFamilyIndex;
-    queueIndex = rhs.queueIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceQueueInfo2 ) );
       return *this;
     }
 
@@ -42237,6 +42245,8 @@
     : fence( fence_ ), handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42251,10 +42261,7 @@
 
     FenceGetFdInfoKHR & operator=( FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fence = rhs.fence;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FenceGetFdInfoKHR ) );
       return *this;
     }
 
@@ -42334,6 +42341,8 @@
     : fence( fence_ ), handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42348,10 +42357,7 @@
 
     FenceGetWin32HandleInfoKHR & operator=( FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fence = rhs.fence;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -42431,6 +42437,8 @@
     : pipelineBindPoint( pipelineBindPoint_ ), pipeline( pipeline_ ), indirectCommandsLayout( indirectCommandsLayout_ ), maxSequencesCount( maxSequencesCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GeneratedCommandsMemoryRequirementsInfoNV( VkGeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42445,12 +42453,7 @@
 
     GeneratedCommandsMemoryRequirementsInfoNV & operator=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pipelineBindPoint = rhs.pipelineBindPoint;
-    pipeline = rhs.pipeline;
-    indirectCommandsLayout = rhs.indirectCommandsLayout;
-    maxSequencesCount = rhs.maxSequencesCount;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GeneratedCommandsMemoryRequirementsInfoNV ) );
       return *this;
     }
 
@@ -42545,6 +42548,8 @@
     : drmFormatModifier( drmFormatModifier_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42559,9 +42564,7 @@
 
     ImageDrmFormatModifierPropertiesEXT & operator=( ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    drmFormatModifier = rhs.drmFormatModifier;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageDrmFormatModifierPropertiesEXT ) );
       return *this;
     }
 
@@ -42620,6 +42623,8 @@
     : image( image_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42634,9 +42639,7 @@
 
     ImageMemoryRequirementsInfo2 & operator=( ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    image = rhs.image;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
       return *this;
     }
 
@@ -42707,6 +42710,8 @@
     : aspectMask( aspectMask_ ), imageGranularity( imageGranularity_ ), flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseImageFormatProperties( SparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42719,6 +42724,12 @@
       return *this;
     }
 
+    SparseImageFormatProperties & operator=( SparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseImageFormatProperties ) );
+      return *this;
+    }
+
 
     operator VkSparseImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -42767,6 +42778,8 @@
     : formatProperties( formatProperties_ ), imageMipTailFirstLod( imageMipTailFirstLod_ ), imageMipTailSize( imageMipTailSize_ ), imageMipTailOffset( imageMipTailOffset_ ), imageMipTailStride( imageMipTailStride_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements( SparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42779,6 +42792,12 @@
       return *this;
     }
 
+    SparseImageMemoryRequirements & operator=( SparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseImageMemoryRequirements ) );
+      return *this;
+    }
+
 
     operator VkSparseImageMemoryRequirements const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -42832,6 +42851,8 @@
     : image( image_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42846,9 +42867,7 @@
 
     ImageSparseMemoryRequirementsInfo2 & operator=( ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    image = rhs.image;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
       return *this;
     }
 
@@ -42920,6 +42939,8 @@
     : memoryRequirements( memoryRequirements_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -42934,9 +42955,7 @@
 
     SparseImageMemoryRequirements2 & operator=( SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memoryRequirements = rhs.memoryRequirements;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseImageMemoryRequirements2 ) );
       return *this;
     }
 
@@ -42995,6 +43014,8 @@
     : offset( offset_ ), size( size_ ), rowPitch( rowPitch_ ), arrayPitch( arrayPitch_ ), depthPitch( depthPitch_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubresourceLayout( SubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubresourceLayout( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43007,6 +43028,12 @@
       return *this;
     }
 
+    SubresourceLayout & operator=( SubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubresourceLayout ) );
+      return *this;
+    }
+
 
     operator VkSubresourceLayout const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -43060,6 +43087,8 @@
     : deviceAddress( deviceAddress_ ), size( size_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( ImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageViewAddressPropertiesNVX( VkImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43074,10 +43103,7 @@
 
     ImageViewAddressPropertiesNVX & operator=( ImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceAddress = rhs.deviceAddress;
-    size = rhs.size;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageViewAddressPropertiesNVX ) );
       return *this;
     }
 
@@ -43138,6 +43164,8 @@
     : imageView( imageView_ ), descriptorType( descriptorType_ ), sampler( sampler_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43152,11 +43180,7 @@
 
     ImageViewHandleInfoNVX & operator=( ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    imageView = rhs.imageView;
-    descriptorType = rhs.descriptorType;
-    sampler = rhs.sampler;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageViewHandleInfoNVX ) );
       return *this;
     }
 
@@ -43244,6 +43268,8 @@
     : memory( memory_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43258,9 +43284,7 @@
 
     MemoryGetAndroidHardwareBufferInfoANDROID & operator=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memory = rhs.memory;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
       return *this;
     }
 
@@ -43332,6 +43356,8 @@
     : memory( memory_ ), handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43346,10 +43372,7 @@
 
     MemoryGetFdInfoKHR & operator=( MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memory = rhs.memory;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryGetFdInfoKHR ) );
       return *this;
     }
 
@@ -43428,6 +43451,8 @@
     : memoryTypeBits( memoryTypeBits_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43442,9 +43467,7 @@
 
     MemoryFdPropertiesKHR & operator=( MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memoryTypeBits = rhs.memoryTypeBits;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryFdPropertiesKHR ) );
       return *this;
     }
 
@@ -43503,6 +43526,8 @@
     : memoryTypeBits( memoryTypeBits_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43517,9 +43542,7 @@
 
     MemoryHostPointerPropertiesEXT & operator=( MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memoryTypeBits = rhs.memoryTypeBits;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
       return *this;
     }
 
@@ -43579,6 +43602,8 @@
     : memory( memory_ ), handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43593,10 +43618,7 @@
 
     MemoryGetWin32HandleInfoKHR & operator=( MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memory = rhs.memory;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -43677,6 +43699,8 @@
     : memoryTypeBits( memoryTypeBits_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43691,9 +43715,7 @@
 
     MemoryWin32HandlePropertiesKHR & operator=( MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memoryTypeBits = rhs.memoryTypeBits;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryWin32HandlePropertiesKHR ) );
       return *this;
     }
 
@@ -43752,6 +43774,8 @@
     : presentID( presentID_ ), desiredPresentTime( desiredPresentTime_ ), actualPresentTime( actualPresentTime_ ), earliestPresentTime( earliestPresentTime_ ), presentMargin( presentMargin_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( PastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43764,6 +43788,12 @@
       return *this;
     }
 
+    PastPresentationTimingGOOGLE & operator=( PastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PastPresentationTimingGOOGLE ) );
+      return *this;
+    }
+
 
     operator VkPastPresentationTimingGOOGLE const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -43900,6 +43930,8 @@
     : type( type_ ), data( data_ )
     {}
 
+    PerformanceValueINTEL( PerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43912,6 +43944,12 @@
       return *this;
     }
 
+    PerformanceValueINTEL & operator=( PerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PerformanceValueINTEL ) );
+      return *this;
+    }
+
     PerformanceValueINTEL & setType( VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type_ ) VULKAN_HPP_NOEXCEPT
     {
       type = type_;
@@ -43956,6 +43994,8 @@
     : pipeline( pipeline_ ), executableIndex( executableIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -43970,10 +44010,7 @@
 
     PipelineExecutableInfoKHR & operator=( PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pipeline = rhs.pipeline;
-    executableIndex = rhs.executableIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineExecutableInfoKHR ) );
       return *this;
     }
 
@@ -44052,6 +44089,8 @@
     : name( name_ ), description( description_ ), isText( isText_ ), dataSize( dataSize_ ), pData( pData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44073,13 +44112,7 @@
 
     PipelineExecutableInternalRepresentationKHR & operator=( PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    name = rhs.name;
-    description = rhs.description;
-    isText = rhs.isText;
-    dataSize = rhs.dataSize;
-    pData = rhs.pData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineExecutableInternalRepresentationKHR ) );
       return *this;
     }
 
@@ -44146,6 +44179,8 @@
     : pipeline( pipeline_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineInfoKHR( PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44160,9 +44195,7 @@
 
     PipelineInfoKHR & operator=( PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pipeline = rhs.pipeline;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineInfoKHR ) );
       return *this;
     }
 
@@ -44233,6 +44266,8 @@
     : stages( stages_ ), name( name_ ), description( description_ ), subgroupSize( subgroupSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44247,12 +44282,7 @@
 
     PipelineExecutablePropertiesKHR & operator=( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    stages = rhs.stages;
-    name = rhs.name;
-    description = rhs.description;
-    subgroupSize = rhs.subgroupSize;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineExecutablePropertiesKHR ) );
       return *this;
     }
 
@@ -44393,6 +44423,8 @@
     : name( name_ ), description( description_ ), format( format_ ), value( value_ )
     {}
 
+    PipelineExecutableStatisticKHR( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44407,12 +44439,7 @@
 
     PipelineExecutableStatisticKHR & operator=( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    name = rhs.name;
-    description = rhs.description;
-    format = rhs.format;
-    value = rhs.value;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineExecutableStatisticKHR ) );
       return *this;
     }
 
@@ -44457,6 +44484,8 @@
     : refreshDuration( refreshDuration_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( RefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44469,6 +44498,12 @@
       return *this;
     }
 
+    RefreshCycleDurationGOOGLE & operator=( RefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RefreshCycleDurationGOOGLE ) );
+      return *this;
+    }
+
 
     operator VkRefreshCycleDurationGOOGLE const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -44514,6 +44549,8 @@
     : semaphore( semaphore_ ), handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44528,10 +44565,7 @@
 
     SemaphoreGetFdInfoKHR & operator=( SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    semaphore = rhs.semaphore;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
       return *this;
     }
 
@@ -44611,6 +44645,8 @@
     : semaphore( semaphore_ ), handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44625,10 +44661,7 @@
 
     SemaphoreGetWin32HandleInfoKHR & operator=( SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    semaphore = rhs.semaphore;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -44708,6 +44741,8 @@
     : fence( fence_ ), flags( flags_ ), handleType( handleType_ ), fd( fd_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44722,12 +44757,7 @@
 
     ImportFenceFdInfoKHR & operator=( ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fence = rhs.fence;
-    flags = rhs.flags;
-    handleType = rhs.handleType;
-    fd = rhs.fd;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportFenceFdInfoKHR ) );
       return *this;
     }
 
@@ -44823,6 +44853,8 @@
     : fence( fence_ ), flags( flags_ ), handleType( handleType_ ), handle( handle_ ), name( name_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44837,13 +44869,7 @@
 
     ImportFenceWin32HandleInfoKHR & operator=( ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fence = rhs.fence;
-    flags = rhs.flags;
-    handleType = rhs.handleType;
-    handle = rhs.handle;
-    name = rhs.name;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -44947,6 +44973,8 @@
     : semaphore( semaphore_ ), flags( flags_ ), handleType( handleType_ ), fd( fd_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -44961,12 +44989,7 @@
 
     ImportSemaphoreFdInfoKHR & operator=( ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    semaphore = rhs.semaphore;
-    flags = rhs.flags;
-    handleType = rhs.handleType;
-    fd = rhs.fd;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
       return *this;
     }
 
@@ -45062,6 +45085,8 @@
     : semaphore( semaphore_ ), flags( flags_ ), handleType( handleType_ ), handle( handle_ ), name( name_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -45076,13 +45101,7 @@
 
     ImportSemaphoreWin32HandleInfoKHR & operator=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    semaphore = rhs.semaphore;
-    flags = rhs.flags;
-    handleType = rhs.handleType;
-    handle = rhs.handle;
-    name = rhs.name;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -45186,6 +45205,8 @@
     : pUserData( pUserData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -45200,9 +45221,7 @@
 
     InitializePerformanceApiInfoINTEL & operator=( InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pUserData = rhs.pUserData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( InitializePerformanceApiInfoINTEL ) );
       return *this;
     }
 
@@ -45273,6 +45292,8 @@
     : displayEvent( displayEvent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -45287,9 +45308,7 @@
 
     DisplayEventInfoEXT & operator=( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    displayEvent = rhs.displayEvent;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayEventInfoEXT ) );
       return *this;
     }
 
@@ -45359,6 +45378,8 @@
     : x( x_ ), y( y_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR XYColorEXT( XYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -45371,6 +45392,12 @@
       return *this;
     }
 
+    XYColorEXT & operator=( XYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( XYColorEXT ) );
+      return *this;
+    }
+
     XYColorEXT & setX( float x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -45430,6 +45457,8 @@
     : displayPrimaryRed( displayPrimaryRed_ ), displayPrimaryGreen( displayPrimaryGreen_ ), displayPrimaryBlue( displayPrimaryBlue_ ), whitePoint( whitePoint_ ), maxLuminance( maxLuminance_ ), minLuminance( minLuminance_ ), maxContentLightLevel( maxContentLightLevel_ ), maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR HdrMetadataEXT( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -45444,16 +45473,7 @@
 
     HdrMetadataEXT & operator=( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    displayPrimaryRed = rhs.displayPrimaryRed;
-    displayPrimaryGreen = rhs.displayPrimaryGreen;
-    displayPrimaryBlue = rhs.displayPrimaryBlue;
-    whitePoint = rhs.whitePoint;
-    maxLuminance = rhs.maxLuminance;
-    minLuminance = rhs.minLuminance;
-    maxContentLightLevel = rhs.maxContentLightLevel;
-    maxFrameAverageLightLevel = rhs.maxFrameAverageLightLevel;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( HdrMetadataEXT ) );
       return *this;
     }
 
@@ -45580,6 +45600,8 @@
     : semaphore( semaphore_ ), value( value_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( SemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SemaphoreSignalInfo( VkSemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -45594,10 +45616,7 @@
 
     SemaphoreSignalInfo & operator=( SemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    semaphore = rhs.semaphore;
-    value = rhs.value;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SemaphoreSignalInfo ) );
       return *this;
     }
 
@@ -45677,6 +45696,8 @@
     : flags( flags_ ), semaphoreCount( semaphoreCount_ ), pSemaphores( pSemaphores_ ), pValues( pValues_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( SemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SemaphoreWaitInfo( VkSemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -45706,12 +45727,7 @@
 
     SemaphoreWaitInfo & operator=( SemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    semaphoreCount = rhs.semaphoreCount;
-    pSemaphores = rhs.pSemaphores;
-    pValues = rhs.pValues;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SemaphoreWaitInfo ) );
       return *this;
     }
 
@@ -47045,13 +47061,19 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, size_t dataSize, void* pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, size_t dataSize, void* pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, ArrayProxy<T> const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getAccelerationStructureHandleNV(  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, ArrayProxy<T> const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Allocator = std::allocator<T>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T,Allocator>>::type getAccelerationStructureHandleNV(  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type getAccelerationStructureHandleNV(  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void getAccelerationStructureMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoKHR* pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2* pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT;
@@ -47513,38 +47535,61 @@
     uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getQueryPoolResults(  VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> const &data, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getQueryPoolResults(  VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> const &data, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Allocator = std::allocator<T>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<T,Allocator>> getQueryPoolResults(  VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD ResultValue<T> getQueryPoolResult(  VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
-    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT;
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getRayTracingCaptureReplayShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Allocator = std::allocator<T>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T,Allocator>>::type getRayTracingCaptureReplayShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type getRayTracingCaptureReplayShaderGroupHandleKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
+
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
-    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT;
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getRayTracingShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Allocator = std::allocator<T>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T,Allocator>>::type getRayTracingShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type getRayTracingShaderGroupHandleKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-    template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getRayTracingShaderGroupHandlesNV(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Allocator = std::allocator<T>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T,Allocator>>::type getRayTracingShaderGroupHandlesNV(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
+    template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type getRayTracingShaderGroupHandleNV(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+
     template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -47992,6 +48037,8 @@
     : visibleRegion( visibleRegion_ ), refreshRate( refreshRate_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( DisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48004,6 +48051,12 @@
       return *this;
     }
 
+    DisplayModeParametersKHR & operator=( DisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayModeParametersKHR ) );
+      return *this;
+    }
+
     DisplayModeParametersKHR & setVisibleRegion( VULKAN_HPP_NAMESPACE::Extent2D const & visibleRegion_ ) VULKAN_HPP_NOEXCEPT
     {
       visibleRegion = visibleRegion_;
@@ -48063,6 +48116,8 @@
     : flags( flags_ ), parameters( parameters_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48077,10 +48132,7 @@
 
     DisplayModeCreateInfoKHR & operator=( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    parameters = rhs.parameters;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayModeCreateInfoKHR ) );
       return *this;
     }
 
@@ -48258,6 +48310,8 @@
     : extensionName( extensionName_ ), specVersion( specVersion_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( ExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExtensionProperties( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48270,6 +48324,12 @@
       return *this;
     }
 
+    ExtensionProperties & operator=( ExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExtensionProperties ) );
+      return *this;
+    }
+
 
     operator VkExtensionProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -48316,6 +48376,8 @@
     : layerName( layerName_ ), specVersion( specVersion_ ), implementationVersion( implementationVersion_ ), description( description_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 LayerProperties( LayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48328,6 +48390,12 @@
       return *this;
     }
 
+    LayerProperties & operator=( LayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( LayerProperties ) );
+      return *this;
+    }
+
 
     operator VkLayerProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -48379,6 +48447,8 @@
     : unit( unit_ ), scope( scope_ ), storage( storage_ ), uuid( uuid_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PerformanceCounterKHR( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48393,12 +48463,7 @@
 
     PerformanceCounterKHR & operator=( PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    unit = rhs.unit;
-    scope = rhs.scope;
-    storage = rhs.storage;
-    uuid = rhs.uuid;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PerformanceCounterKHR ) );
       return *this;
     }
 
@@ -48463,6 +48528,8 @@
     : flags( flags_ ), name( name_ ), category( category_ ), description( description_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PerformanceCounterDescriptionKHR( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48477,12 +48544,7 @@
 
     PerformanceCounterDescriptionKHR & operator=( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    name = rhs.name;
-    category = rhs.category;
-    description = rhs.description;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PerformanceCounterDescriptionKHR ) );
       return *this;
     }
 
@@ -48546,6 +48608,8 @@
     : displayMode( displayMode_ ), parameters( parameters_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( DisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48558,6 +48622,12 @@
       return *this;
     }
 
+    DisplayModePropertiesKHR & operator=( DisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayModePropertiesKHR ) );
+      return *this;
+    }
+
 
     operator VkDisplayModePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -48605,6 +48675,8 @@
     : displayModeProperties( displayModeProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48619,9 +48691,7 @@
 
     DisplayModeProperties2KHR & operator=( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    displayModeProperties = rhs.displayModeProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayModeProperties2KHR ) );
       return *this;
     }
 
@@ -48680,6 +48750,8 @@
     : mode( mode_ ), planeIndex( planeIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48694,10 +48766,7 @@
 
     DisplayPlaneInfo2KHR & operator=( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    mode = rhs.mode;
-    planeIndex = rhs.planeIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayPlaneInfo2KHR ) );
       return *this;
     }
 
@@ -48775,6 +48844,8 @@
     : supportedAlpha( supportedAlpha_ ), minSrcPosition( minSrcPosition_ ), maxSrcPosition( maxSrcPosition_ ), minSrcExtent( minSrcExtent_ ), maxSrcExtent( maxSrcExtent_ ), minDstPosition( minDstPosition_ ), maxDstPosition( maxDstPosition_ ), minDstExtent( minDstExtent_ ), maxDstExtent( maxDstExtent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( DisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48787,6 +48858,12 @@
       return *this;
     }
 
+    DisplayPlaneCapabilitiesKHR & operator=( DisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayPlaneCapabilitiesKHR ) );
+      return *this;
+    }
+
 
     operator VkDisplayPlaneCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -48848,6 +48925,8 @@
     : capabilities( capabilities_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48862,9 +48941,7 @@
 
     DisplayPlaneCapabilities2KHR & operator=( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    capabilities = rhs.capabilities;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayPlaneCapabilities2KHR ) );
       return *this;
     }
 
@@ -48922,6 +48999,8 @@
     : currentDisplay( currentDisplay_ ), currentStackIndex( currentStackIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( DisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48934,6 +49013,12 @@
       return *this;
     }
 
+    DisplayPlanePropertiesKHR & operator=( DisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayPlanePropertiesKHR ) );
+      return *this;
+    }
+
 
     operator VkDisplayPlanePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -48981,6 +49066,8 @@
     : displayPlaneProperties( displayPlaneProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -48995,9 +49082,7 @@
 
     DisplayPlaneProperties2KHR & operator=( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    displayPlaneProperties = rhs.displayPlaneProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayPlaneProperties2KHR ) );
       return *this;
     }
 
@@ -49055,6 +49140,8 @@
     : display( display_ ), displayName( displayName_ ), physicalDimensions( physicalDimensions_ ), physicalResolution( physicalResolution_ ), supportedTransforms( supportedTransforms_ ), planeReorderPossible( planeReorderPossible_ ), persistentContent( persistentContent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( DisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49067,6 +49154,12 @@
       return *this;
     }
 
+    DisplayPropertiesKHR & operator=( DisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayPropertiesKHR ) );
+      return *this;
+    }
+
 
     operator VkDisplayPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -49124,6 +49217,8 @@
     : displayProperties( displayProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49138,9 +49233,7 @@
 
     DisplayProperties2KHR & operator=( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    displayProperties = rhs.displayProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayProperties2KHR ) );
       return *this;
     }
 
@@ -49199,6 +49292,8 @@
     : flags( flags_ ), usage( usage_ ), handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49213,11 +49308,7 @@
 
     PhysicalDeviceExternalBufferInfo & operator=( PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    usage = rhs.usage;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
       return *this;
     }
 
@@ -49304,6 +49395,8 @@
     : externalMemoryFeatures( externalMemoryFeatures_ ), exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ), compatibleHandleTypes( compatibleHandleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalMemoryProperties( ExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalMemoryProperties( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49316,6 +49409,12 @@
       return *this;
     }
 
+    ExternalMemoryProperties & operator=( ExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalMemoryProperties ) );
+      return *this;
+    }
+
 
     operator VkExternalMemoryProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -49366,6 +49465,8 @@
     : externalMemoryProperties( externalMemoryProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalBufferProperties( ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49380,9 +49481,7 @@
 
     ExternalBufferProperties & operator=( ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    externalMemoryProperties = rhs.externalMemoryProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalBufferProperties ) );
       return *this;
     }
 
@@ -49442,6 +49541,8 @@
     : handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49456,9 +49557,7 @@
 
     PhysicalDeviceExternalFenceInfo & operator=( PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
       return *this;
     }
 
@@ -49530,6 +49629,8 @@
     : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ), compatibleHandleTypes( compatibleHandleTypes_ ), externalFenceFeatures( externalFenceFeatures_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalFenceProperties( ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49544,11 +49645,7 @@
 
     ExternalFenceProperties & operator=( ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    exportFromImportedHandleTypes = rhs.exportFromImportedHandleTypes;
-    compatibleHandleTypes = rhs.compatibleHandleTypes;
-    externalFenceFeatures = rhs.externalFenceFeatures;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalFenceProperties ) );
       return *this;
     }
 
@@ -49611,6 +49708,8 @@
     : maxExtent( maxExtent_ ), maxMipLevels( maxMipLevels_ ), maxArrayLayers( maxArrayLayers_ ), sampleCounts( sampleCounts_ ), maxResourceSize( maxResourceSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageFormatProperties( ImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageFormatProperties( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49623,6 +49722,12 @@
       return *this;
     }
 
+    ImageFormatProperties & operator=( ImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageFormatProperties ) );
+      return *this;
+    }
+
 
     operator VkImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -49675,6 +49780,8 @@
     : imageFormatProperties( imageFormatProperties_ ), externalMemoryFeatures( externalMemoryFeatures_ ), exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ), compatibleHandleTypes( compatibleHandleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalImageFormatPropertiesNV( ExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49687,6 +49794,12 @@
       return *this;
     }
 
+    ExternalImageFormatPropertiesNV & operator=( ExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalImageFormatPropertiesNV ) );
+      return *this;
+    }
+
 
     operator VkExternalImageFormatPropertiesNV const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -49738,6 +49851,8 @@
     : handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49752,9 +49867,7 @@
 
     PhysicalDeviceExternalSemaphoreInfo & operator=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
       return *this;
     }
 
@@ -49826,6 +49939,8 @@
     : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ), compatibleHandleTypes( compatibleHandleTypes_ ), externalSemaphoreFeatures( externalSemaphoreFeatures_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49840,11 +49955,7 @@
 
     ExternalSemaphoreProperties & operator=( ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    exportFromImportedHandleTypes = rhs.exportFromImportedHandleTypes;
-    compatibleHandleTypes = rhs.compatibleHandleTypes;
-    externalSemaphoreFeatures = rhs.externalSemaphoreFeatures;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalSemaphoreProperties ) );
       return *this;
     }
 
@@ -49908,6 +50019,8 @@
     : features( features_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -49922,9 +50035,7 @@
 
     PhysicalDeviceFeatures2 & operator=( PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    features = rhs.features;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFeatures2 ) );
       return *this;
     }
 
@@ -49995,6 +50106,8 @@
     : linearTilingFeatures( linearTilingFeatures_ ), optimalTilingFeatures( optimalTilingFeatures_ ), bufferFeatures( bufferFeatures_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FormatProperties( FormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FormatProperties( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50007,6 +50120,12 @@
       return *this;
     }
 
+    FormatProperties & operator=( FormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FormatProperties ) );
+      return *this;
+    }
+
 
     operator VkFormatProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -50056,6 +50175,8 @@
     : formatProperties( formatProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FormatProperties2( FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50070,9 +50191,7 @@
 
     FormatProperties2 & operator=( FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    formatProperties = rhs.formatProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FormatProperties2 ) );
       return *this;
     }
 
@@ -50132,6 +50251,8 @@
     : format( format_ ), type( type_ ), tiling( tiling_ ), usage( usage_ ), flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50146,13 +50267,7 @@
 
     PhysicalDeviceImageFormatInfo2 & operator=( PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    format = rhs.format;
-    type = rhs.type;
-    tiling = rhs.tiling;
-    usage = rhs.usage;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
       return *this;
     }
 
@@ -50256,6 +50371,8 @@
     : imageFormatProperties( imageFormatProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageFormatProperties2( ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50270,9 +50387,7 @@
 
     ImageFormatProperties2 & operator=( ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    imageFormatProperties = rhs.imageFormatProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageFormatProperties2 ) );
       return *this;
     }
 
@@ -50331,6 +50446,8 @@
     : propertyFlags( propertyFlags_ ), heapIndex( heapIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryType( MemoryType const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryType( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50343,6 +50460,12 @@
       return *this;
     }
 
+    MemoryType & operator=( MemoryType const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryType ) );
+      return *this;
+    }
+
 
     operator VkMemoryType const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -50389,6 +50512,8 @@
     : size( size_ ), flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryHeap( MemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryHeap( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50401,6 +50526,12 @@
       return *this;
     }
 
+    MemoryHeap & operator=( MemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryHeap ) );
+      return *this;
+    }
+
 
     operator VkMemoryHeap const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -50447,6 +50578,8 @@
     : memoryTypeCount( memoryTypeCount_ ), memoryTypes( memoryTypes_ ), memoryHeapCount( memoryHeapCount_ ), memoryHeaps( memoryHeaps_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( PhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50459,6 +50592,12 @@
       return *this;
     }
 
+    PhysicalDeviceMemoryProperties & operator=( PhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMemoryProperties ) );
+      return *this;
+    }
+
 
     operator VkPhysicalDeviceMemoryProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -50510,6 +50649,8 @@
     : memoryProperties( memoryProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50524,9 +50665,7 @@
 
     PhysicalDeviceMemoryProperties2 & operator=( PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memoryProperties = rhs.memoryProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMemoryProperties2 ) );
       return *this;
     }
 
@@ -50586,6 +50725,8 @@
     : maxSampleLocationGridSize( maxSampleLocationGridSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50600,9 +50741,7 @@
 
     MultisamplePropertiesEXT & operator=( MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxSampleLocationGridSize = rhs.maxSampleLocationGridSize;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MultisamplePropertiesEXT ) );
       return *this;
     }
 
@@ -50660,6 +50799,8 @@
     : 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( maxComputeWorkGroupCount_ ), maxComputeWorkGroupInvocations( maxComputeWorkGroupInvocations_ ), maxComputeWorkGroupSize( maxComputeWorkGroupSize_ ), subPixelPrecisionBits( subPixelPrecisionBits_ ), subTexelPrecisionBits( subTexelPrecisionBits_ ), mipmapPrecisionBits( mipmapPrecisionBits_ ), maxDrawIndexedIndexValue( maxDrawIndexedIndexValue_ ), maxDrawIndirectCount( maxDrawIndirectCount_ ), maxSamplerLodBias( maxSamplerLodBias_ ), maxSamplerAnisotropy( maxSamplerAnisotropy_ ), maxViewports( maxViewports_ ), maxViewportDimensions( maxViewportDimensions_ ), viewportBoundsRange( 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( pointSizeRange_ ), lineWidthRange( lineWidthRange_ ), pointSizeGranularity( pointSizeGranularity_ ), lineWidthGranularity( lineWidthGranularity_ ), strictLines( strictLines_ ), standardSampleLocations( standardSampleLocations_ ), optimalBufferCopyOffsetAlignment( optimalBufferCopyOffsetAlignment_ ), optimalBufferCopyRowPitchAlignment( optimalBufferCopyRowPitchAlignment_ ), nonCoherentAtomSize( nonCoherentAtomSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLimits( PhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50672,6 +50813,12 @@
       return *this;
     }
 
+    PhysicalDeviceLimits & operator=( PhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceLimits ) );
+      return *this;
+    }
+
 
     operator VkPhysicalDeviceLimits const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -50926,6 +51073,8 @@
     : residencyStandard2DBlockShape( residencyStandard2DBlockShape_ ), residencyStandard2DMultisampleBlockShape( residencyStandard2DMultisampleBlockShape_ ), residencyStandard3DBlockShape( residencyStandard3DBlockShape_ ), residencyAlignedMipSize( residencyAlignedMipSize_ ), residencyNonResidentStrict( residencyNonResidentStrict_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( PhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -50938,6 +51087,12 @@
       return *this;
     }
 
+    PhysicalDeviceSparseProperties & operator=( PhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSparseProperties ) );
+      return *this;
+    }
+
 
     operator VkPhysicalDeviceSparseProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -50990,6 +51145,8 @@
     : apiVersion( apiVersion_ ), driverVersion( driverVersion_ ), vendorID( vendorID_ ), deviceID( deviceID_ ), deviceType( deviceType_ ), deviceName( deviceName_ ), pipelineCacheUUID( pipelineCacheUUID_ ), limits( limits_ ), sparseProperties( sparseProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties( PhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51002,6 +51159,12 @@
       return *this;
     }
 
+    PhysicalDeviceProperties & operator=( PhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceProperties ) );
+      return *this;
+    }
+
 
     operator VkPhysicalDeviceProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -51063,6 +51226,8 @@
     : properties( properties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51077,9 +51242,7 @@
 
     PhysicalDeviceProperties2 & operator=( PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    properties = rhs.properties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceProperties2 ) );
       return *this;
     }
 
@@ -51139,6 +51302,8 @@
     : queueFamilyIndex( queueFamilyIndex_ ), counterIndexCount( counterIndexCount_ ), pCounterIndices( pCounterIndices_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     QueryPoolPerformanceCreateInfoKHR( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51159,11 +51324,7 @@
 
     QueryPoolPerformanceCreateInfoKHR & operator=( QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    queueFamilyIndex = rhs.queueFamilyIndex;
-    counterIndexCount = rhs.counterIndexCount;
-    pCounterIndices = rhs.pCounterIndices;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( QueryPoolPerformanceCreateInfoKHR ) );
       return *this;
     }
 
@@ -51258,6 +51419,8 @@
     : queueFlags( queueFlags_ ), queueCount( queueCount_ ), timestampValidBits( timestampValidBits_ ), minImageTransferGranularity( minImageTransferGranularity_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR QueueFamilyProperties( QueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51270,6 +51433,12 @@
       return *this;
     }
 
+    QueueFamilyProperties & operator=( QueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( QueueFamilyProperties ) );
+      return *this;
+    }
+
 
     operator VkQueueFamilyProperties const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -51321,6 +51490,8 @@
     : queueFamilyProperties( queueFamilyProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51335,9 +51506,7 @@
 
     QueueFamilyProperties2 & operator=( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    queueFamilyProperties = rhs.queueFamilyProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( QueueFamilyProperties2 ) );
       return *this;
     }
 
@@ -51397,6 +51566,8 @@
     : format( format_ ), type( type_ ), samples( samples_ ), usage( usage_ ), tiling( tiling_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51411,13 +51582,7 @@
 
     PhysicalDeviceSparseImageFormatInfo2 & operator=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    format = rhs.format;
-    type = rhs.type;
-    samples = rhs.samples;
-    usage = rhs.usage;
-    tiling = rhs.tiling;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
       return *this;
     }
 
@@ -51521,6 +51686,8 @@
     : properties( properties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51535,9 +51702,7 @@
 
     SparseImageFormatProperties2 & operator=( SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    properties = rhs.properties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SparseImageFormatProperties2 ) );
       return *this;
     }
 
@@ -51597,6 +51762,8 @@
     : coverageReductionMode( coverageReductionMode_ ), rasterizationSamples( rasterizationSamples_ ), depthStencilSamples( depthStencilSamples_ ), colorSamples( colorSamples_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51611,12 +51778,7 @@
 
     FramebufferMixedSamplesCombinationNV & operator=( FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    coverageReductionMode = rhs.coverageReductionMode;
-    rasterizationSamples = rhs.rasterizationSamples;
-    depthStencilSamples = rhs.depthStencilSamples;
-    colorSamples = rhs.colorSamples;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FramebufferMixedSamplesCombinationNV ) );
       return *this;
     }
 
@@ -51681,6 +51843,8 @@
     : minImageCount( minImageCount_ ), maxImageCount( maxImageCount_ ), currentExtent( currentExtent_ ), minImageExtent( minImageExtent_ ), maxImageExtent( maxImageExtent_ ), maxImageArrayLayers( maxImageArrayLayers_ ), supportedTransforms( supportedTransforms_ ), currentTransform( currentTransform_ ), supportedCompositeAlpha( supportedCompositeAlpha_ ), supportedUsageFlags( supportedUsageFlags_ ), supportedSurfaceCounters( supportedSurfaceCounters_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51695,19 +51859,7 @@
 
     SurfaceCapabilities2EXT & operator=( SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    minImageCount = rhs.minImageCount;
-    maxImageCount = rhs.maxImageCount;
-    currentExtent = rhs.currentExtent;
-    minImageExtent = rhs.minImageExtent;
-    maxImageExtent = rhs.maxImageExtent;
-    maxImageArrayLayers = rhs.maxImageArrayLayers;
-    supportedTransforms = rhs.supportedTransforms;
-    currentTransform = rhs.currentTransform;
-    supportedCompositeAlpha = rhs.supportedCompositeAlpha;
-    supportedUsageFlags = rhs.supportedUsageFlags;
-    supportedSurfaceCounters = rhs.supportedSurfaceCounters;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceCapabilities2EXT ) );
       return *this;
     }
 
@@ -51785,6 +51937,8 @@
     : minImageCount( minImageCount_ ), maxImageCount( maxImageCount_ ), currentExtent( currentExtent_ ), minImageExtent( minImageExtent_ ), maxImageExtent( maxImageExtent_ ), maxImageArrayLayers( maxImageArrayLayers_ ), supportedTransforms( supportedTransforms_ ), currentTransform( currentTransform_ ), supportedCompositeAlpha( supportedCompositeAlpha_ ), supportedUsageFlags( supportedUsageFlags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesKHR( SurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51797,6 +51951,12 @@
       return *this;
     }
 
+    SurfaceCapabilitiesKHR & operator=( SurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceCapabilitiesKHR ) );
+      return *this;
+    }
+
 
     operator VkSurfaceCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -51860,6 +52020,8 @@
     : surfaceCapabilities( surfaceCapabilities_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51874,9 +52036,7 @@
 
     SurfaceCapabilities2KHR & operator=( SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    surfaceCapabilities = rhs.surfaceCapabilities;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceCapabilities2KHR ) );
       return *this;
     }
 
@@ -51934,6 +52094,8 @@
     : format( format_ ), colorSpace( colorSpace_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceFormatKHR( SurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -51946,6 +52108,12 @@
       return *this;
     }
 
+    SurfaceFormatKHR & operator=( SurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceFormatKHR ) );
+      return *this;
+    }
+
 
     operator VkSurfaceFormatKHR const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -51993,6 +52161,8 @@
     : surfaceFormat( surfaceFormat_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -52007,9 +52177,7 @@
 
     SurfaceFormat2KHR & operator=( SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    surfaceFormat = rhs.surfaceFormat;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceFormat2KHR ) );
       return *this;
     }
 
@@ -52068,6 +52236,8 @@
     : name( name_ ), version( version_ ), purposes( purposes_ ), description( description_ ), layer( layer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolPropertiesEXT( PhysicalDeviceToolPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceToolPropertiesEXT( VkPhysicalDeviceToolPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -52082,13 +52252,7 @@
 
     PhysicalDeviceToolPropertiesEXT & operator=( PhysicalDeviceToolPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    name = rhs.name;
-    version = rhs.version;
-    purposes = rhs.purposes;
-    description = rhs.description;
-    layer = rhs.layer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceToolPropertiesEXT ) );
       return *this;
     }
 
@@ -52817,6 +52981,8 @@
     : physicalDeviceCount( physicalDeviceCount_ ), pPhysicalDevices( pPhysicalDevices_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -52837,10 +53003,7 @@
 
     DeviceGroupDeviceCreateInfo & operator=( DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    physicalDeviceCount = rhs.physicalDeviceCount;
-    pPhysicalDevices = rhs.pPhysicalDevices;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
       return *this;
     }
 
@@ -52929,6 +53092,8 @@
     : swapchainCount( swapchainCount_ ), pDeviceMasks( pDeviceMasks_ ), mode( mode_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -52949,11 +53114,7 @@
 
     DeviceGroupPresentInfoKHR & operator=( DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    swapchainCount = rhs.swapchainCount;
-    pDeviceMasks = rhs.pDeviceMasks;
-    mode = rhs.mode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
       return *this;
     }
 
@@ -53049,6 +53210,8 @@
     : deviceMask( deviceMask_ ), deviceRenderAreaCount( deviceRenderAreaCount_ ), pDeviceRenderAreas( pDeviceRenderAreas_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53069,11 +53232,7 @@
 
     DeviceGroupRenderPassBeginInfo & operator=( DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceMask = rhs.deviceMask;
-    deviceRenderAreaCount = rhs.deviceRenderAreaCount;
-    pDeviceRenderAreas = rhs.pDeviceRenderAreas;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
       return *this;
     }
 
@@ -53170,6 +53329,8 @@
     : waitSemaphoreCount( waitSemaphoreCount_ ), pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ), commandBufferCount( commandBufferCount_ ), pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ), signalSemaphoreCount( signalSemaphoreCount_ ), pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53190,14 +53351,7 @@
 
     DeviceGroupSubmitInfo & operator=( DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    waitSemaphoreCount = rhs.waitSemaphoreCount;
-    pWaitSemaphoreDeviceIndices = rhs.pWaitSemaphoreDeviceIndices;
-    commandBufferCount = rhs.commandBufferCount;
-    pCommandBufferDeviceMasks = rhs.pCommandBufferDeviceMasks;
-    signalSemaphoreCount = rhs.signalSemaphoreCount;
-    pSignalSemaphoreDeviceIndices = rhs.pSignalSemaphoreDeviceIndices;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceGroupSubmitInfo ) );
       return *this;
     }
 
@@ -53336,6 +53490,8 @@
     : modes( modes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53350,9 +53506,7 @@
 
     DeviceGroupSwapchainCreateInfoKHR & operator=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    modes = rhs.modes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
       return *this;
     }
 
@@ -53423,6 +53577,8 @@
     : overallocationBehavior( overallocationBehavior_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53437,9 +53593,7 @@
 
     DeviceMemoryOverallocationCreateInfoAMD & operator=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    overallocationBehavior = rhs.overallocationBehavior;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
       return *this;
     }
 
@@ -53510,6 +53664,8 @@
     : privateDataSlotRequestCount( privateDataSlotRequestCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DevicePrivateDataCreateInfoEXT( DevicePrivateDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DevicePrivateDataCreateInfoEXT( VkDevicePrivateDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53524,9 +53680,7 @@
 
     DevicePrivateDataCreateInfoEXT & operator=( DevicePrivateDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    privateDataSlotRequestCount = rhs.privateDataSlotRequestCount;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DevicePrivateDataCreateInfoEXT ) );
       return *this;
     }
 
@@ -53597,6 +53751,8 @@
     : globalPriority( globalPriority_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53611,9 +53767,7 @@
 
     DeviceQueueGlobalPriorityCreateInfoEXT & operator=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    globalPriority = rhs.globalPriority;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
       return *this;
     }
 
@@ -53685,6 +53839,8 @@
     : flags( flags_ ), dfb( dfb_ ), surface( surface_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DirectFBSurfaceCreateInfoEXT( DirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DirectFBSurfaceCreateInfoEXT( VkDirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53699,11 +53855,7 @@
 
     DirectFBSurfaceCreateInfoEXT & operator=( DirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    dfb = rhs.dfb;
-    surface = rhs.surface;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DirectFBSurfaceCreateInfoEXT ) );
       return *this;
     }
 
@@ -53790,6 +53942,8 @@
     : x( x_ ), y( y_ ), z( z_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( DispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53802,6 +53956,12 @@
       return *this;
     }
 
+    DispatchIndirectCommand & operator=( DispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DispatchIndirectCommand ) );
+      return *this;
+    }
+
     DispatchIndirectCommand & setX( uint32_t x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -53869,6 +54029,8 @@
     : localDimmingSupport( localDimmingSupport_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53883,9 +54045,7 @@
 
     DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    localDimmingSupport = rhs.localDimmingSupport;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) );
       return *this;
     }
 
@@ -53944,6 +54104,8 @@
     : srcRect( srcRect_ ), dstRect( dstRect_ ), persistent( persistent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -53958,11 +54120,7 @@
 
     DisplayPresentInfoKHR & operator=( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    srcRect = rhs.srcRect;
-    dstRect = rhs.dstRect;
-    persistent = rhs.persistent;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplayPresentInfoKHR ) );
       return *this;
     }
 
@@ -54049,6 +54207,8 @@
     : flags( flags_ ), displayMode( displayMode_ ), planeIndex( planeIndex_ ), planeStackIndex( planeStackIndex_ ), transform( transform_ ), globalAlpha( globalAlpha_ ), alphaMode( alphaMode_ ), imageExtent( imageExtent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54063,16 +54223,7 @@
 
     DisplaySurfaceCreateInfoKHR & operator=( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    displayMode = rhs.displayMode;
-    planeIndex = rhs.planeIndex;
-    planeStackIndex = rhs.planeStackIndex;
-    transform = rhs.transform;
-    globalAlpha = rhs.globalAlpha;
-    alphaMode = rhs.alphaMode;
-    imageExtent = rhs.imageExtent;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
       return *this;
     }
 
@@ -54198,6 +54349,8 @@
     : indexCount( indexCount_ ), instanceCount( instanceCount_ ), firstIndex( firstIndex_ ), vertexOffset( vertexOffset_ ), firstInstance( firstInstance_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( DrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54210,6 +54363,12 @@
       return *this;
     }
 
+    DrawIndexedIndirectCommand & operator=( DrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DrawIndexedIndirectCommand ) );
+      return *this;
+    }
+
     DrawIndexedIndirectCommand & setIndexCount( uint32_t indexCount_ ) VULKAN_HPP_NOEXCEPT
     {
       indexCount = indexCount_;
@@ -54292,6 +54451,8 @@
     : vertexCount( vertexCount_ ), instanceCount( instanceCount_ ), firstVertex( firstVertex_ ), firstInstance( firstInstance_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DrawIndirectCommand( DrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54304,6 +54465,12 @@
       return *this;
     }
 
+    DrawIndirectCommand & operator=( DrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DrawIndirectCommand ) );
+      return *this;
+    }
+
     DrawIndirectCommand & setVertexCount( uint32_t vertexCount_ ) VULKAN_HPP_NOEXCEPT
     {
       vertexCount = vertexCount_;
@@ -54378,6 +54545,8 @@
     : taskCount( taskCount_ ), firstTask( firstTask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( DrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54390,6 +54559,12 @@
       return *this;
     }
 
+    DrawMeshTasksIndirectCommandNV & operator=( DrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+      return *this;
+    }
+
     DrawMeshTasksIndirectCommandNV & setTaskCount( uint32_t taskCount_ ) VULKAN_HPP_NOEXCEPT
     {
       taskCount = taskCount_;
@@ -54448,6 +54623,8 @@
     : drmFormatModifier( drmFormatModifier_ ), drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ), drmFormatModifierTilingFeatures( drmFormatModifierTilingFeatures_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesEXT( DrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DrmFormatModifierPropertiesEXT( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54460,6 +54637,12 @@
       return *this;
     }
 
+    DrmFormatModifierPropertiesEXT & operator=( DrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DrmFormatModifierPropertiesEXT ) );
+      return *this;
+    }
+
 
     operator VkDrmFormatModifierPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -54509,6 +54692,8 @@
     : drmFormatModifierCount( drmFormatModifierCount_ ), pDrmFormatModifierProperties( pDrmFormatModifierProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54529,10 +54714,7 @@
 
     DrmFormatModifierPropertiesListEXT & operator=( DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    drmFormatModifierCount = rhs.drmFormatModifierCount;
-    pDrmFormatModifierProperties = rhs.pDrmFormatModifierProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
       return *this;
     }
 
@@ -54593,6 +54775,8 @@
     : handleTypes( handleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54607,9 +54791,7 @@
 
     ExportFenceCreateInfo & operator=( ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleTypes = rhs.handleTypes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExportFenceCreateInfo ) );
       return *this;
     }
 
@@ -54682,6 +54864,8 @@
     : pAttributes( pAttributes_ ), dwAccess( dwAccess_ ), name( name_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54696,11 +54880,7 @@
 
     ExportFenceWin32HandleInfoKHR & operator=( ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pAttributes = rhs.pAttributes;
-    dwAccess = rhs.dwAccess;
-    name = rhs.name;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -54788,6 +54968,8 @@
     : handleTypes( handleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54802,9 +54984,7 @@
 
     ExportMemoryAllocateInfo & operator=( ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleTypes = rhs.handleTypes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExportMemoryAllocateInfo ) );
       return *this;
     }
 
@@ -54876,6 +55056,8 @@
     : handleTypes( handleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54890,9 +55072,7 @@
 
     ExportMemoryAllocateInfoNV & operator=( ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleTypes = rhs.handleTypes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
       return *this;
     }
 
@@ -54964,6 +55144,8 @@
     : pAttributes( pAttributes_ ), dwAccess( dwAccess_ ), name( name_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -54978,11 +55160,7 @@
 
     ExportMemoryWin32HandleInfoKHR & operator=( ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pAttributes = rhs.pAttributes;
-    dwAccess = rhs.dwAccess;
-    name = rhs.name;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -55071,6 +55249,8 @@
     : pAttributes( pAttributes_ ), dwAccess( dwAccess_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55085,10 +55265,7 @@
 
     ExportMemoryWin32HandleInfoNV & operator=( ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pAttributes = rhs.pAttributes;
-    dwAccess = rhs.dwAccess;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
       return *this;
     }
 
@@ -55168,6 +55345,8 @@
     : handleTypes( handleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55182,9 +55361,7 @@
 
     ExportSemaphoreCreateInfo & operator=( ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleTypes = rhs.handleTypes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExportSemaphoreCreateInfo ) );
       return *this;
     }
 
@@ -55257,6 +55434,8 @@
     : pAttributes( pAttributes_ ), dwAccess( dwAccess_ ), name( name_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55271,11 +55450,7 @@
 
     ExportSemaphoreWin32HandleInfoKHR & operator=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pAttributes = rhs.pAttributes;
-    dwAccess = rhs.dwAccess;
-    name = rhs.name;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -55364,6 +55539,8 @@
     : externalFormat( externalFormat_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55378,9 +55555,7 @@
 
     ExternalFormatANDROID & operator=( ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    externalFormat = rhs.externalFormat;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalFormatANDROID ) );
       return *this;
     }
 
@@ -55452,6 +55627,8 @@
     : externalMemoryProperties( externalMemoryProperties_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55466,9 +55643,7 @@
 
     ExternalImageFormatProperties & operator=( ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    externalMemoryProperties = rhs.externalMemoryProperties;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalImageFormatProperties ) );
       return *this;
     }
 
@@ -55528,6 +55703,8 @@
     : handleTypes( handleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55542,9 +55719,7 @@
 
     ExternalMemoryBufferCreateInfo & operator=( ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleTypes = rhs.handleTypes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
       return *this;
     }
 
@@ -55616,6 +55791,8 @@
     : handleTypes( handleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55630,9 +55807,7 @@
 
     ExternalMemoryImageCreateInfo & operator=( ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleTypes = rhs.handleTypes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
       return *this;
     }
 
@@ -55704,6 +55879,8 @@
     : handleTypes( handleTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55718,9 +55895,7 @@
 
     ExternalMemoryImageCreateInfoNV & operator=( ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleTypes = rhs.handleTypes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
       return *this;
     }
 
@@ -55791,6 +55966,8 @@
     : filterCubic( filterCubic_ ), filterCubicMinmax( filterCubicMinmax_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FilterCubicImageViewImageFormatPropertiesEXT( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55805,10 +55982,7 @@
 
     FilterCubicImageViewImageFormatPropertiesEXT & operator=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    filterCubic = rhs.filterCubic;
-    filterCubicMinmax = rhs.filterCubicMinmax;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) );
       return *this;
     }
 
@@ -55869,6 +56043,8 @@
     : flags( flags_ ), usage( usage_ ), width( width_ ), height( height_ ), layerCount( layerCount_ ), viewFormatCount( viewFormatCount_ ), pViewFormats( pViewFormats_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( FramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FramebufferAttachmentImageInfo( VkFramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -55889,15 +56065,7 @@
 
     FramebufferAttachmentImageInfo & operator=( FramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    usage = rhs.usage;
-    width = rhs.width;
-    height = rhs.height;
-    layerCount = rhs.layerCount;
-    viewFormatCount = rhs.viewFormatCount;
-    pViewFormats = rhs.pViewFormats;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FramebufferAttachmentImageInfo ) );
       return *this;
     }
 
@@ -56026,6 +56194,8 @@
     : attachmentImageInfoCount( attachmentImageInfoCount_ ), pAttachmentImageInfos( pAttachmentImageInfos_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( FramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     FramebufferAttachmentsCreateInfo( VkFramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56046,10 +56216,7 @@
 
     FramebufferAttachmentsCreateInfo & operator=( FramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    attachmentImageInfoCount = rhs.attachmentImageInfoCount;
-    pAttachmentImageInfos = rhs.pAttachmentImageInfos;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( FramebufferAttachmentsCreateInfo ) );
       return *this;
     }
 
@@ -56138,6 +56305,8 @@
     : stageCount( stageCount_ ), pStages( pStages_ ), pVertexInputState( pVertexInputState_ ), pTessellationState( pTessellationState_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( GraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GraphicsShaderGroupCreateInfoNV( VkGraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56158,12 +56327,7 @@
 
     GraphicsShaderGroupCreateInfoNV & operator=( GraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    stageCount = rhs.stageCount;
-    pStages = rhs.pStages;
-    pVertexInputState = rhs.pVertexInputState;
-    pTessellationState = rhs.pTessellationState;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GraphicsShaderGroupCreateInfoNV ) );
       return *this;
     }
 
@@ -56267,6 +56431,8 @@
     : groupCount( groupCount_ ), pGroups( pGroups_ ), pipelineCount( pipelineCount_ ), pPipelines( pPipelines_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     GraphicsPipelineShaderGroupsCreateInfoNV( VkGraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56287,12 +56453,7 @@
 
     GraphicsPipelineShaderGroupsCreateInfoNV & operator=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    groupCount = rhs.groupCount;
-    pGroups = rhs.pGroups;
-    pipelineCount = rhs.pipelineCount;
-    pPipelines = rhs.pPipelines;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( GraphicsPipelineShaderGroupsCreateInfoNV ) );
       return *this;
     }
 
@@ -56405,6 +56566,8 @@
     : flags( flags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56419,9 +56582,7 @@
 
     HeadlessSurfaceCreateInfoEXT & operator=( HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( HeadlessSurfaceCreateInfoEXT ) );
       return *this;
     }
 
@@ -56493,6 +56654,8 @@
     : flags( flags_ ), pView( pView_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56507,10 +56670,7 @@
 
     IOSSurfaceCreateInfoMVK & operator=( IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pView = rhs.pView;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
       return *this;
     }
 
@@ -56590,6 +56750,8 @@
     : drmFormatModifier( drmFormatModifier_ ), drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ), pPlaneLayouts( pPlaneLayouts_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56610,11 +56772,7 @@
 
     ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    drmFormatModifier = rhs.drmFormatModifier;
-    drmFormatModifierPlaneCount = rhs.drmFormatModifierPlaneCount;
-    pPlaneLayouts = rhs.pPlaneLayouts;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
       return *this;
     }
 
@@ -56710,6 +56868,8 @@
     : drmFormatModifierCount( drmFormatModifierCount_ ), pDrmFormatModifiers( pDrmFormatModifiers_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56730,10 +56890,7 @@
 
     ImageDrmFormatModifierListCreateInfoEXT & operator=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    drmFormatModifierCount = rhs.drmFormatModifierCount;
-    pDrmFormatModifiers = rhs.pDrmFormatModifiers;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
       return *this;
     }
 
@@ -56821,6 +56978,8 @@
     : viewFormatCount( viewFormatCount_ ), pViewFormats( pViewFormats_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfo( ImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageFormatListCreateInfo( VkImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56841,10 +57000,7 @@
 
     ImageFormatListCreateInfo & operator=( ImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    viewFormatCount = rhs.viewFormatCount;
-    pViewFormats = rhs.pViewFormats;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageFormatListCreateInfo ) );
       return *this;
     }
 
@@ -56934,6 +57090,8 @@
     : flags( flags_ ), imagePipeHandle( imagePipeHandle_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -56948,10 +57106,7 @@
 
     ImagePipeSurfaceCreateInfoFUCHSIA & operator=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    imagePipeHandle = rhs.imagePipeHandle;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
       return *this;
     }
 
@@ -57031,6 +57186,8 @@
     : planeAspect( planeAspect_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57045,9 +57202,7 @@
 
     ImagePlaneMemoryRequirementsInfo & operator=( ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    planeAspect = rhs.planeAspect;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
       return *this;
     }
 
@@ -57119,6 +57274,8 @@
     : stencilUsage( stencilUsage_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( ImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageStencilUsageCreateInfo( VkImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57133,9 +57290,7 @@
 
     ImageStencilUsageCreateInfo & operator=( ImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    stencilUsage = rhs.stencilUsage;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageStencilUsageCreateInfo ) );
       return *this;
     }
 
@@ -57207,6 +57362,8 @@
     : swapchain( swapchain_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57221,9 +57378,7 @@
 
     ImageSwapchainCreateInfoKHR & operator=( ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    swapchain = rhs.swapchain;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
       return *this;
     }
 
@@ -57294,6 +57449,8 @@
     : decodeMode( decodeMode_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57308,9 +57465,7 @@
 
     ImageViewASTCDecodeModeEXT & operator=( ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    decodeMode = rhs.decodeMode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
       return *this;
     }
 
@@ -57381,6 +57536,8 @@
     : usage( usage_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57395,9 +57552,7 @@
 
     ImageViewUsageCreateInfo & operator=( ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    usage = rhs.usage;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImageViewUsageCreateInfo ) );
       return *this;
     }
 
@@ -57470,6 +57625,8 @@
     : buffer( buffer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57484,9 +57641,7 @@
 
     ImportAndroidHardwareBufferInfoANDROID & operator=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    buffer = rhs.buffer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
       return *this;
     }
 
@@ -57558,6 +57713,8 @@
     : handleType( handleType_ ), fd( fd_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57572,10 +57729,7 @@
 
     ImportMemoryFdInfoKHR & operator=( ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleType = rhs.handleType;
-    fd = rhs.fd;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportMemoryFdInfoKHR ) );
       return *this;
     }
 
@@ -57654,6 +57808,8 @@
     : handleType( handleType_ ), pHostPointer( pHostPointer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57668,10 +57824,7 @@
 
     ImportMemoryHostPointerInfoEXT & operator=( ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleType = rhs.handleType;
-    pHostPointer = rhs.pHostPointer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
       return *this;
     }
 
@@ -57751,6 +57904,8 @@
     : handleType( handleType_ ), handle( handle_ ), name( name_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57765,11 +57920,7 @@
 
     ImportMemoryWin32HandleInfoKHR & operator=( ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleType = rhs.handleType;
-    handle = rhs.handle;
-    name = rhs.name;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
       return *this;
     }
 
@@ -57858,6 +58009,8 @@
     : handleType( handleType_ ), handle( handle_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57872,10 +58025,7 @@
 
     ImportMemoryWin32HandleInfoNV & operator=( ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleType = rhs.handleType;
-    handle = rhs.handle;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
       return *this;
     }
 
@@ -57954,6 +58104,8 @@
     : subpass( subpass_ ), inputAttachmentIndex( inputAttachmentIndex_ ), aspectMask( aspectMask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR InputAttachmentAspectReference( InputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -57966,6 +58118,12 @@
       return *this;
     }
 
+    InputAttachmentAspectReference & operator=( InputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( InputAttachmentAspectReference ) );
+      return *this;
+    }
+
     InputAttachmentAspectReference & setSubpass( uint32_t subpass_ ) VULKAN_HPP_NOEXCEPT
     {
       subpass = subpass_;
@@ -58034,6 +58192,8 @@
     : flags( flags_ ), pApplicationInfo( pApplicationInfo_ ), enabledLayerCount( enabledLayerCount_ ), ppEnabledLayerNames( ppEnabledLayerNames_ ), enabledExtensionCount( enabledExtensionCount_ ), ppEnabledExtensionNames( ppEnabledExtensionNames_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR InstanceCreateInfo( InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58054,14 +58214,7 @@
 
     InstanceCreateInfo & operator=( InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pApplicationInfo = rhs.pApplicationInfo;
-    enabledLayerCount = rhs.enabledLayerCount;
-    ppEnabledLayerNames = rhs.ppEnabledLayerNames;
-    enabledExtensionCount = rhs.enabledExtensionCount;
-    ppEnabledExtensionNames = rhs.ppEnabledExtensionNames;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( InstanceCreateInfo ) );
       return *this;
     }
 
@@ -58191,6 +58344,8 @@
     : flags( flags_ ), pView( pView_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58205,10 +58360,7 @@
 
     MacOSSurfaceCreateInfoMVK & operator=( MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pView = rhs.pView;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
       return *this;
     }
 
@@ -58288,6 +58440,8 @@
     : flags( flags_ ), deviceMask( deviceMask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58302,10 +58456,7 @@
 
     MemoryAllocateFlagsInfo & operator=( MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    deviceMask = rhs.deviceMask;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryAllocateFlagsInfo ) );
       return *this;
     }
 
@@ -58385,6 +58536,8 @@
     : image( image_ ), buffer( buffer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58399,10 +58552,7 @@
 
     MemoryDedicatedAllocateInfo & operator=( MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    image = rhs.image;
-    buffer = rhs.buffer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
       return *this;
     }
 
@@ -58482,6 +58632,8 @@
     : prefersDedicatedAllocation( prefersDedicatedAllocation_ ), requiresDedicatedAllocation( requiresDedicatedAllocation_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58496,10 +58648,7 @@
 
     MemoryDedicatedRequirements & operator=( MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    prefersDedicatedAllocation = rhs.prefersDedicatedAllocation;
-    requiresDedicatedAllocation = rhs.requiresDedicatedAllocation;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryDedicatedRequirements ) );
       return *this;
     }
 
@@ -58561,6 +58710,8 @@
     : opaqueCaptureAddress( opaqueCaptureAddress_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryOpaqueCaptureAddressAllocateInfo( VkMemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58575,9 +58726,7 @@
 
     MemoryOpaqueCaptureAddressAllocateInfo & operator=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    opaqueCaptureAddress = rhs.opaqueCaptureAddress;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryOpaqueCaptureAddressAllocateInfo ) );
       return *this;
     }
 
@@ -58649,6 +58798,8 @@
     : priority( priority_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58663,9 +58814,7 @@
 
     MemoryPriorityAllocateInfoEXT & operator=( MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    priority = rhs.priority;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MemoryPriorityAllocateInfoEXT ) );
       return *this;
     }
 
@@ -58737,6 +58886,8 @@
     : flags( flags_ ), pLayer( pLayer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58751,10 +58902,7 @@
 
     MetalSurfaceCreateInfoEXT & operator=( MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    pLayer = rhs.pLayer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MetalSurfaceCreateInfoEXT ) );
       return *this;
     }
 
@@ -58925,6 +59073,8 @@
     : counterPassIndex( counterPassIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PerformanceQuerySubmitInfoKHR( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -58939,9 +59089,7 @@
 
     PerformanceQuerySubmitInfoKHR & operator=( PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    counterPassIndex = rhs.counterPassIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PerformanceQuerySubmitInfoKHR ) );
       return *this;
     }
 
@@ -59012,6 +59160,8 @@
     : storageBuffer16BitAccess( storageBuffer16BitAccess_ ), uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ), storagePushConstant16( storagePushConstant16_ ), storageInputOutput16( storageInputOutput16_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59026,12 +59176,7 @@
 
     PhysicalDevice16BitStorageFeatures & operator=( PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    storageBuffer16BitAccess = rhs.storageBuffer16BitAccess;
-    uniformAndStorageBuffer16BitAccess = rhs.uniformAndStorageBuffer16BitAccess;
-    storagePushConstant16 = rhs.storagePushConstant16;
-    storageInputOutput16 = rhs.storageInputOutput16;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) );
       return *this;
     }
 
@@ -59127,6 +59272,8 @@
     : formatA4R4G4B4( formatA4R4G4B4_ ), formatA4B4G4R4( formatA4B4G4R4_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevice4444FormatsFeaturesEXT( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevice4444FormatsFeaturesEXT( VkPhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59141,10 +59288,7 @@
 
     PhysicalDevice4444FormatsFeaturesEXT & operator=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    formatA4R4G4B4 = rhs.formatA4R4G4B4;
-    formatA4B4G4R4 = rhs.formatA4B4G4R4;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevice4444FormatsFeaturesEXT ) );
       return *this;
     }
 
@@ -59223,6 +59367,8 @@
     : storageBuffer8BitAccess( storageBuffer8BitAccess_ ), uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ ), storagePushConstant8( storagePushConstant8_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( PhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevice8BitStorageFeatures( VkPhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59237,11 +59383,7 @@
 
     PhysicalDevice8BitStorageFeatures & operator=( PhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    storageBuffer8BitAccess = rhs.storageBuffer8BitAccess;
-    uniformAndStorageBuffer8BitAccess = rhs.uniformAndStorageBuffer8BitAccess;
-    storagePushConstant8 = rhs.storagePushConstant8;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevice8BitStorageFeatures ) );
       return *this;
     }
 
@@ -59329,6 +59471,8 @@
     : decodeModeSharedExponent( decodeModeSharedExponent_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59343,9 +59487,7 @@
 
     PhysicalDeviceASTCDecodeFeaturesEXT & operator=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    decodeModeSharedExponent = rhs.decodeModeSharedExponent;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
       return *this;
     }
 
@@ -59416,6 +59558,8 @@
     : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59430,9 +59574,7 @@
 
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    advancedBlendCoherentOperations = rhs.advancedBlendCoherentOperations;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) );
       return *this;
     }
 
@@ -59503,6 +59645,8 @@
     : advancedBlendMaxColorAttachments( advancedBlendMaxColorAttachments_ ), advancedBlendIndependentBlend( advancedBlendIndependentBlend_ ), advancedBlendNonPremultipliedSrcColor( advancedBlendNonPremultipliedSrcColor_ ), advancedBlendNonPremultipliedDstColor( advancedBlendNonPremultipliedDstColor_ ), advancedBlendCorrelatedOverlap( advancedBlendCorrelatedOverlap_ ), advancedBlendAllOperations( advancedBlendAllOperations_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedPropertiesEXT( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59517,14 +59661,7 @@
 
     PhysicalDeviceBlendOperationAdvancedPropertiesEXT & operator=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    advancedBlendMaxColorAttachments = rhs.advancedBlendMaxColorAttachments;
-    advancedBlendIndependentBlend = rhs.advancedBlendIndependentBlend;
-    advancedBlendNonPremultipliedSrcColor = rhs.advancedBlendNonPremultipliedSrcColor;
-    advancedBlendNonPremultipliedDstColor = rhs.advancedBlendNonPremultipliedDstColor;
-    advancedBlendCorrelatedOverlap = rhs.advancedBlendCorrelatedOverlap;
-    advancedBlendAllOperations = rhs.advancedBlendAllOperations;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) );
       return *this;
     }
 
@@ -59593,6 +59730,8 @@
     : bufferDeviceAddress( bufferDeviceAddress_ ), bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ), bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceBufferDeviceAddressFeatures( VkPhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59607,11 +59746,7 @@
 
     PhysicalDeviceBufferDeviceAddressFeatures & operator=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    bufferDeviceAddress = rhs.bufferDeviceAddress;
-    bufferDeviceAddressCaptureReplay = rhs.bufferDeviceAddressCaptureReplay;
-    bufferDeviceAddressMultiDevice = rhs.bufferDeviceAddressMultiDevice;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceBufferDeviceAddressFeatures ) );
       return *this;
     }
 
@@ -59699,6 +59834,8 @@
     : bufferDeviceAddress( bufferDeviceAddress_ ), bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ), bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59713,11 +59850,7 @@
 
     PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    bufferDeviceAddress = rhs.bufferDeviceAddress;
-    bufferDeviceAddressCaptureReplay = rhs.bufferDeviceAddressCaptureReplay;
-    bufferDeviceAddressMultiDevice = rhs.bufferDeviceAddressMultiDevice;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) );
       return *this;
     }
 
@@ -59805,6 +59938,8 @@
     : deviceCoherentMemory( deviceCoherentMemory_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59819,9 +59954,7 @@
 
     PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceCoherentMemory = rhs.deviceCoherentMemory;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) );
       return *this;
     }
 
@@ -59892,6 +60025,8 @@
     : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ ), computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -59906,10 +60041,7 @@
 
     PhysicalDeviceComputeShaderDerivativesFeaturesNV & operator=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    computeDerivativeGroupQuads = rhs.computeDerivativeGroupQuads;
-    computeDerivativeGroupLinear = rhs.computeDerivativeGroupLinear;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
       return *this;
     }
 
@@ -59988,6 +60120,8 @@
     : conditionalRendering( conditionalRendering_ ), inheritedConditionalRendering( inheritedConditionalRendering_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60002,10 +60136,7 @@
 
     PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    conditionalRendering = rhs.conditionalRendering;
-    inheritedConditionalRendering = rhs.inheritedConditionalRendering;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) );
       return *this;
     }
 
@@ -60084,6 +60215,8 @@
     : primitiveOverestimationSize( primitiveOverestimationSize_ ), maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ ), extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ ), primitiveUnderestimation( primitiveUnderestimation_ ), conservativePointAndLineRasterization( conservativePointAndLineRasterization_ ), degenerateTrianglesRasterized( degenerateTrianglesRasterized_ ), degenerateLinesRasterized( degenerateLinesRasterized_ ), fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ ), conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceConservativeRasterizationPropertiesEXT( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60098,17 +60231,7 @@
 
     PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    primitiveOverestimationSize = rhs.primitiveOverestimationSize;
-    maxExtraPrimitiveOverestimationSize = rhs.maxExtraPrimitiveOverestimationSize;
-    extraPrimitiveOverestimationSizeGranularity = rhs.extraPrimitiveOverestimationSizeGranularity;
-    primitiveUnderestimation = rhs.primitiveUnderestimation;
-    conservativePointAndLineRasterization = rhs.conservativePointAndLineRasterization;
-    degenerateTrianglesRasterized = rhs.degenerateTrianglesRasterized;
-    degenerateLinesRasterized = rhs.degenerateLinesRasterized;
-    fullyCoveredFragmentShaderInputVariable = rhs.fullyCoveredFragmentShaderInputVariable;
-    conservativeRasterizationPostDepthCoverage = rhs.conservativeRasterizationPostDepthCoverage;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) );
       return *this;
     }
 
@@ -60183,6 +60306,8 @@
     : cooperativeMatrix( cooperativeMatrix_ ), cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60197,10 +60322,7 @@
 
     PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    cooperativeMatrix = rhs.cooperativeMatrix;
-    cooperativeMatrixRobustBufferAccess = rhs.cooperativeMatrixRobustBufferAccess;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) );
       return *this;
     }
 
@@ -60279,6 +60401,8 @@
     : cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60293,9 +60417,7 @@
 
     PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    cooperativeMatrixSupportedStages = rhs.cooperativeMatrixSupportedStages;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) );
       return *this;
     }
 
@@ -60354,6 +60476,8 @@
     : cornerSampledImage( cornerSampledImage_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60368,9 +60492,7 @@
 
     PhysicalDeviceCornerSampledImageFeaturesNV & operator=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    cornerSampledImage = rhs.cornerSampledImage;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
       return *this;
     }
 
@@ -60441,6 +60563,8 @@
     : coverageReductionMode( coverageReductionMode_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60455,9 +60579,7 @@
 
     PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    coverageReductionMode = rhs.coverageReductionMode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) );
       return *this;
     }
 
@@ -60528,6 +60650,8 @@
     : customBorderColors( customBorderColors_ ), customBorderColorWithoutFormat( customBorderColorWithoutFormat_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorFeaturesEXT( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceCustomBorderColorFeaturesEXT( VkPhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60542,10 +60666,7 @@
 
     PhysicalDeviceCustomBorderColorFeaturesEXT & operator=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    customBorderColors = rhs.customBorderColors;
-    customBorderColorWithoutFormat = rhs.customBorderColorWithoutFormat;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceCustomBorderColorFeaturesEXT ) );
       return *this;
     }
 
@@ -60624,6 +60745,8 @@
     : maxCustomBorderColorSamplers( maxCustomBorderColorSamplers_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorPropertiesEXT( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceCustomBorderColorPropertiesEXT( VkPhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60638,9 +60761,7 @@
 
     PhysicalDeviceCustomBorderColorPropertiesEXT & operator=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxCustomBorderColorSamplers = rhs.maxCustomBorderColorSamplers;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceCustomBorderColorPropertiesEXT ) );
       return *this;
     }
 
@@ -60699,6 +60820,8 @@
     : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60713,9 +60836,7 @@
 
     PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & operator=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    dedicatedAllocationImageAliasing = rhs.dedicatedAllocationImageAliasing;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) );
       return *this;
     }
 
@@ -60786,6 +60907,8 @@
     : depthClipEnable( depthClipEnable_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60800,9 +60923,7 @@
 
     PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    depthClipEnable = rhs.depthClipEnable;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) );
       return *this;
     }
 
@@ -60873,6 +60994,8 @@
     : supportedDepthResolveModes( supportedDepthResolveModes_ ), supportedStencilResolveModes( supportedStencilResolveModes_ ), independentResolveNone( independentResolveNone_ ), independentResolve( independentResolve_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( PhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDepthStencilResolveProperties( VkPhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60887,12 +61010,7 @@
 
     PhysicalDeviceDepthStencilResolveProperties & operator=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    supportedDepthResolveModes = rhs.supportedDepthResolveModes;
-    supportedStencilResolveModes = rhs.supportedStencilResolveModes;
-    independentResolveNone = rhs.independentResolveNone;
-    independentResolve = rhs.independentResolve;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDepthStencilResolveProperties ) );
       return *this;
     }
 
@@ -60958,6 +61076,8 @@
     : 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_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDescriptorIndexingFeatures( VkPhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -60972,28 +61092,7 @@
 
     PhysicalDeviceDescriptorIndexingFeatures & operator=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderInputAttachmentArrayDynamicIndexing = rhs.shaderInputAttachmentArrayDynamicIndexing;
-    shaderUniformTexelBufferArrayDynamicIndexing = rhs.shaderUniformTexelBufferArrayDynamicIndexing;
-    shaderStorageTexelBufferArrayDynamicIndexing = rhs.shaderStorageTexelBufferArrayDynamicIndexing;
-    shaderUniformBufferArrayNonUniformIndexing = rhs.shaderUniformBufferArrayNonUniformIndexing;
-    shaderSampledImageArrayNonUniformIndexing = rhs.shaderSampledImageArrayNonUniformIndexing;
-    shaderStorageBufferArrayNonUniformIndexing = rhs.shaderStorageBufferArrayNonUniformIndexing;
-    shaderStorageImageArrayNonUniformIndexing = rhs.shaderStorageImageArrayNonUniformIndexing;
-    shaderInputAttachmentArrayNonUniformIndexing = rhs.shaderInputAttachmentArrayNonUniformIndexing;
-    shaderUniformTexelBufferArrayNonUniformIndexing = rhs.shaderUniformTexelBufferArrayNonUniformIndexing;
-    shaderStorageTexelBufferArrayNonUniformIndexing = rhs.shaderStorageTexelBufferArrayNonUniformIndexing;
-    descriptorBindingUniformBufferUpdateAfterBind = rhs.descriptorBindingUniformBufferUpdateAfterBind;
-    descriptorBindingSampledImageUpdateAfterBind = rhs.descriptorBindingSampledImageUpdateAfterBind;
-    descriptorBindingStorageImageUpdateAfterBind = rhs.descriptorBindingStorageImageUpdateAfterBind;
-    descriptorBindingStorageBufferUpdateAfterBind = rhs.descriptorBindingStorageBufferUpdateAfterBind;
-    descriptorBindingUniformTexelBufferUpdateAfterBind = rhs.descriptorBindingUniformTexelBufferUpdateAfterBind;
-    descriptorBindingStorageTexelBufferUpdateAfterBind = rhs.descriptorBindingStorageTexelBufferUpdateAfterBind;
-    descriptorBindingUpdateUnusedWhilePending = rhs.descriptorBindingUpdateUnusedWhilePending;
-    descriptorBindingPartiallyBound = rhs.descriptorBindingPartiallyBound;
-    descriptorBindingVariableDescriptorCount = rhs.descriptorBindingVariableDescriptorCount;
-    runtimeDescriptorArray = rhs.runtimeDescriptorArray;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeatures ) );
       return *this;
     }
 
@@ -61217,6 +61316,8 @@
     : 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_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( PhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDescriptorIndexingProperties( VkPhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61231,31 +61332,7 @@
 
     PhysicalDeviceDescriptorIndexingProperties & operator=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxUpdateAfterBindDescriptorsInAllPools = rhs.maxUpdateAfterBindDescriptorsInAllPools;
-    shaderUniformBufferArrayNonUniformIndexingNative = rhs.shaderUniformBufferArrayNonUniformIndexingNative;
-    shaderSampledImageArrayNonUniformIndexingNative = rhs.shaderSampledImageArrayNonUniformIndexingNative;
-    shaderStorageBufferArrayNonUniformIndexingNative = rhs.shaderStorageBufferArrayNonUniformIndexingNative;
-    shaderStorageImageArrayNonUniformIndexingNative = rhs.shaderStorageImageArrayNonUniformIndexingNative;
-    shaderInputAttachmentArrayNonUniformIndexingNative = rhs.shaderInputAttachmentArrayNonUniformIndexingNative;
-    robustBufferAccessUpdateAfterBind = rhs.robustBufferAccessUpdateAfterBind;
-    quadDivergentImplicitLod = rhs.quadDivergentImplicitLod;
-    maxPerStageDescriptorUpdateAfterBindSamplers = rhs.maxPerStageDescriptorUpdateAfterBindSamplers;
-    maxPerStageDescriptorUpdateAfterBindUniformBuffers = rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
-    maxPerStageDescriptorUpdateAfterBindStorageBuffers = rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
-    maxPerStageDescriptorUpdateAfterBindSampledImages = rhs.maxPerStageDescriptorUpdateAfterBindSampledImages;
-    maxPerStageDescriptorUpdateAfterBindStorageImages = rhs.maxPerStageDescriptorUpdateAfterBindStorageImages;
-    maxPerStageDescriptorUpdateAfterBindInputAttachments = rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments;
-    maxPerStageUpdateAfterBindResources = rhs.maxPerStageUpdateAfterBindResources;
-    maxDescriptorSetUpdateAfterBindSamplers = rhs.maxDescriptorSetUpdateAfterBindSamplers;
-    maxDescriptorSetUpdateAfterBindUniformBuffers = rhs.maxDescriptorSetUpdateAfterBindUniformBuffers;
-    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
-    maxDescriptorSetUpdateAfterBindStorageBuffers = rhs.maxDescriptorSetUpdateAfterBindStorageBuffers;
-    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
-    maxDescriptorSetUpdateAfterBindSampledImages = rhs.maxDescriptorSetUpdateAfterBindSampledImages;
-    maxDescriptorSetUpdateAfterBindStorageImages = rhs.maxDescriptorSetUpdateAfterBindStorageImages;
-    maxDescriptorSetUpdateAfterBindInputAttachments = rhs.maxDescriptorSetUpdateAfterBindInputAttachments;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDescriptorIndexingProperties ) );
       return *this;
     }
 
@@ -61359,6 +61436,8 @@
     : deviceGeneratedCommands( deviceGeneratedCommands_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61373,9 +61452,7 @@
 
     PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & operator=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceGeneratedCommands = rhs.deviceGeneratedCommands;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV ) );
       return *this;
     }
 
@@ -61446,6 +61523,8 @@
     : maxGraphicsShaderGroupCount( maxGraphicsShaderGroupCount_ ), maxIndirectSequenceCount( maxIndirectSequenceCount_ ), maxIndirectCommandsTokenCount( maxIndirectCommandsTokenCount_ ), maxIndirectCommandsStreamCount( maxIndirectCommandsStreamCount_ ), maxIndirectCommandsTokenOffset( maxIndirectCommandsTokenOffset_ ), maxIndirectCommandsStreamStride( maxIndirectCommandsStreamStride_ ), minSequencesCountBufferOffsetAlignment( minSequencesCountBufferOffsetAlignment_ ), minSequencesIndexBufferOffsetAlignment( minSequencesIndexBufferOffsetAlignment_ ), minIndirectCommandsBufferOffsetAlignment( minIndirectCommandsBufferOffsetAlignment_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61460,17 +61539,7 @@
 
     PhysicalDeviceDeviceGeneratedCommandsPropertiesNV & operator=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxGraphicsShaderGroupCount = rhs.maxGraphicsShaderGroupCount;
-    maxIndirectSequenceCount = rhs.maxIndirectSequenceCount;
-    maxIndirectCommandsTokenCount = rhs.maxIndirectCommandsTokenCount;
-    maxIndirectCommandsStreamCount = rhs.maxIndirectCommandsStreamCount;
-    maxIndirectCommandsTokenOffset = rhs.maxIndirectCommandsTokenOffset;
-    maxIndirectCommandsStreamStride = rhs.maxIndirectCommandsStreamStride;
-    minSequencesCountBufferOffsetAlignment = rhs.minSequencesCountBufferOffsetAlignment;
-    minSequencesIndexBufferOffsetAlignment = rhs.minSequencesIndexBufferOffsetAlignment;
-    minIndirectCommandsBufferOffsetAlignment = rhs.minIndirectCommandsBufferOffsetAlignment;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV ) );
       return *this;
     }
 
@@ -61545,6 +61614,8 @@
     : diagnosticsConfig( diagnosticsConfig_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDiagnosticsConfigFeaturesNV( VkPhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61559,9 +61630,7 @@
 
     PhysicalDeviceDiagnosticsConfigFeaturesNV & operator=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    diagnosticsConfig = rhs.diagnosticsConfig;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDiagnosticsConfigFeaturesNV ) );
       return *this;
     }
 
@@ -61632,6 +61701,8 @@
     : maxDiscardRectangles( maxDiscardRectangles_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61646,9 +61717,7 @@
 
     PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxDiscardRectangles = rhs.maxDiscardRectangles;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
       return *this;
     }
 
@@ -61707,6 +61776,8 @@
     : driverID( driverID_ ), driverName( driverName_ ), driverInfo( driverInfo_ ), conformanceVersion( conformanceVersion_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceDriverProperties( VkPhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61721,12 +61792,7 @@
 
     PhysicalDeviceDriverProperties & operator=( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    driverID = rhs.driverID;
-    driverName = rhs.driverName;
-    driverInfo = rhs.driverInfo;
-    conformanceVersion = rhs.conformanceVersion;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceDriverProperties ) );
       return *this;
     }
 
@@ -61792,6 +61858,8 @@
     : exclusiveScissor( exclusiveScissor_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61806,9 +61874,7 @@
 
     PhysicalDeviceExclusiveScissorFeaturesNV & operator=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    exclusiveScissor = rhs.exclusiveScissor;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
       return *this;
     }
 
@@ -61879,6 +61945,8 @@
     : extendedDynamicState( extendedDynamicState_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicStateFeaturesEXT( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceExtendedDynamicStateFeaturesEXT( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61893,9 +61961,7 @@
 
     PhysicalDeviceExtendedDynamicStateFeaturesEXT & operator=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    extendedDynamicState = rhs.extendedDynamicState;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceExtendedDynamicStateFeaturesEXT ) );
       return *this;
     }
 
@@ -61966,6 +62032,8 @@
     : handleType( handleType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -61980,9 +62048,7 @@
 
     PhysicalDeviceExternalImageFormatInfo & operator=( PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    handleType = rhs.handleType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
       return *this;
     }
 
@@ -62054,6 +62120,8 @@
     : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryHostPropertiesEXT( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62068,9 +62136,7 @@
 
     PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    minImportedHostPointerAlignment = rhs.minImportedHostPointerAlignment;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
       return *this;
     }
 
@@ -62129,6 +62195,8 @@
     : 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_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFloatControlsProperties( PhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFloatControlsProperties( VkPhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62143,25 +62211,7 @@
 
     PhysicalDeviceFloatControlsProperties & operator=( PhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    denormBehaviorIndependence = rhs.denormBehaviorIndependence;
-    roundingModeIndependence = rhs.roundingModeIndependence;
-    shaderSignedZeroInfNanPreserveFloat16 = rhs.shaderSignedZeroInfNanPreserveFloat16;
-    shaderSignedZeroInfNanPreserveFloat32 = rhs.shaderSignedZeroInfNanPreserveFloat32;
-    shaderSignedZeroInfNanPreserveFloat64 = rhs.shaderSignedZeroInfNanPreserveFloat64;
-    shaderDenormPreserveFloat16 = rhs.shaderDenormPreserveFloat16;
-    shaderDenormPreserveFloat32 = rhs.shaderDenormPreserveFloat32;
-    shaderDenormPreserveFloat64 = rhs.shaderDenormPreserveFloat64;
-    shaderDenormFlushToZeroFloat16 = rhs.shaderDenormFlushToZeroFloat16;
-    shaderDenormFlushToZeroFloat32 = rhs.shaderDenormFlushToZeroFloat32;
-    shaderDenormFlushToZeroFloat64 = rhs.shaderDenormFlushToZeroFloat64;
-    shaderRoundingModeRTEFloat16 = rhs.shaderRoundingModeRTEFloat16;
-    shaderRoundingModeRTEFloat32 = rhs.shaderRoundingModeRTEFloat32;
-    shaderRoundingModeRTEFloat64 = rhs.shaderRoundingModeRTEFloat64;
-    shaderRoundingModeRTZFloat16 = rhs.shaderRoundingModeRTZFloat16;
-    shaderRoundingModeRTZFloat32 = rhs.shaderRoundingModeRTZFloat32;
-    shaderRoundingModeRTZFloat64 = rhs.shaderRoundingModeRTZFloat64;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFloatControlsProperties ) );
       return *this;
     }
 
@@ -62253,6 +62303,8 @@
     : fragmentDensityMapDeferred( fragmentDensityMapDeferred_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2FeaturesEXT( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFragmentDensityMap2FeaturesEXT( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62267,9 +62319,7 @@
 
     PhysicalDeviceFragmentDensityMap2FeaturesEXT & operator=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fragmentDensityMapDeferred = rhs.fragmentDensityMapDeferred;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFragmentDensityMap2FeaturesEXT ) );
       return *this;
     }
 
@@ -62340,6 +62390,8 @@
     : subsampledLoads( subsampledLoads_ ), subsampledCoarseReconstructionEarlyAccess( subsampledCoarseReconstructionEarlyAccess_ ), maxSubsampledArrayLayers( maxSubsampledArrayLayers_ ), maxDescriptorSetSubsampledSamplers( maxDescriptorSetSubsampledSamplers_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2PropertiesEXT( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFragmentDensityMap2PropertiesEXT( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62354,12 +62406,7 @@
 
     PhysicalDeviceFragmentDensityMap2PropertiesEXT & operator=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    subsampledLoads = rhs.subsampledLoads;
-    subsampledCoarseReconstructionEarlyAccess = rhs.subsampledCoarseReconstructionEarlyAccess;
-    maxSubsampledArrayLayers = rhs.maxSubsampledArrayLayers;
-    maxDescriptorSetSubsampledSamplers = rhs.maxDescriptorSetSubsampledSamplers;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFragmentDensityMap2PropertiesEXT ) );
       return *this;
     }
 
@@ -62424,6 +62471,8 @@
     : fragmentDensityMap( fragmentDensityMap_ ), fragmentDensityMapDynamic( fragmentDensityMapDynamic_ ), fragmentDensityMapNonSubsampledImages( fragmentDensityMapNonSubsampledImages_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62438,11 +62487,7 @@
 
     PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fragmentDensityMap = rhs.fragmentDensityMap;
-    fragmentDensityMapDynamic = rhs.fragmentDensityMapDynamic;
-    fragmentDensityMapNonSubsampledImages = rhs.fragmentDensityMapNonSubsampledImages;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) );
       return *this;
     }
 
@@ -62529,6 +62574,8 @@
     : minFragmentDensityTexelSize( minFragmentDensityTexelSize_ ), maxFragmentDensityTexelSize( maxFragmentDensityTexelSize_ ), fragmentDensityInvocations( fragmentDensityInvocations_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapPropertiesEXT( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62543,11 +62590,7 @@
 
     PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    minFragmentDensityTexelSize = rhs.minFragmentDensityTexelSize;
-    maxFragmentDensityTexelSize = rhs.maxFragmentDensityTexelSize;
-    fragmentDensityInvocations = rhs.fragmentDensityInvocations;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) );
       return *this;
     }
 
@@ -62610,6 +62653,8 @@
     : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62624,9 +62669,7 @@
 
     PhysicalDeviceFragmentShaderBarycentricFeaturesNV & operator=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fragmentShaderBarycentric = rhs.fragmentShaderBarycentric;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
       return *this;
     }
 
@@ -62697,6 +62740,8 @@
     : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ ), fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ ), fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62711,11 +62756,7 @@
 
     PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fragmentShaderSampleInterlock = rhs.fragmentShaderSampleInterlock;
-    fragmentShaderPixelInterlock = rhs.fragmentShaderPixelInterlock;
-    fragmentShaderShadingRateInterlock = rhs.fragmentShaderShadingRateInterlock;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) );
       return *this;
     }
 
@@ -62802,6 +62843,8 @@
     : physicalDeviceCount( physicalDeviceCount_ ), physicalDevices( physicalDevices_ ), subsetAllocation( subsetAllocation_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62816,11 +62859,7 @@
 
     PhysicalDeviceGroupProperties & operator=( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    physicalDeviceCount = rhs.physicalDeviceCount;
-    physicalDevices = rhs.physicalDevices;
-    subsetAllocation = rhs.subsetAllocation;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceGroupProperties ) );
       return *this;
     }
 
@@ -62884,6 +62923,8 @@
     : hostQueryReset( hostQueryReset_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( PhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceHostQueryResetFeatures( VkPhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62898,9 +62939,7 @@
 
     PhysicalDeviceHostQueryResetFeatures & operator=( PhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    hostQueryReset = rhs.hostQueryReset;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceHostQueryResetFeatures ) );
       return *this;
     }
 
@@ -62972,6 +63011,8 @@
     : deviceUUID( deviceUUID_ ), driverUUID( driverUUID_ ), deviceLUID( deviceLUID_ ), deviceNodeMask( deviceNodeMask_ ), deviceLUIDValid( deviceLUIDValid_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -62986,13 +63027,7 @@
 
     PhysicalDeviceIDProperties & operator=( PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceUUID = rhs.deviceUUID;
-    driverUUID = rhs.driverUUID;
-    deviceLUID = rhs.deviceLUID;
-    deviceNodeMask = rhs.deviceNodeMask;
-    deviceLUIDValid = rhs.deviceLUIDValid;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceIDProperties ) );
       return *this;
     }
 
@@ -63060,6 +63095,8 @@
     : drmFormatModifier( drmFormatModifier_ ), sharingMode( sharingMode_ ), queueFamilyIndexCount( queueFamilyIndexCount_ ), pQueueFamilyIndices( pQueueFamilyIndices_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63080,12 +63117,7 @@
 
     PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    drmFormatModifier = rhs.drmFormatModifier;
-    sharingMode = rhs.sharingMode;
-    queueFamilyIndexCount = rhs.queueFamilyIndexCount;
-    pQueueFamilyIndices = rhs.pQueueFamilyIndices;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
       return *this;
     }
 
@@ -63189,6 +63221,8 @@
     : robustImageAccess( robustImageAccess_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceImageRobustnessFeaturesEXT( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceImageRobustnessFeaturesEXT( VkPhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63203,9 +63237,7 @@
 
     PhysicalDeviceImageRobustnessFeaturesEXT & operator=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    robustImageAccess = rhs.robustImageAccess;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceImageRobustnessFeaturesEXT ) );
       return *this;
     }
 
@@ -63276,6 +63308,8 @@
     : imageViewType( imageViewType_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63290,9 +63324,7 @@
 
     PhysicalDeviceImageViewImageFormatInfoEXT & operator=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    imageViewType = rhs.imageViewType;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) );
       return *this;
     }
 
@@ -63363,6 +63395,8 @@
     : imagelessFramebuffer( imagelessFramebuffer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceImagelessFramebufferFeatures( VkPhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63377,9 +63411,7 @@
 
     PhysicalDeviceImagelessFramebufferFeatures & operator=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    imagelessFramebuffer = rhs.imagelessFramebuffer;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceImagelessFramebufferFeatures ) );
       return *this;
     }
 
@@ -63451,6 +63483,8 @@
     : indexTypeUint8( indexTypeUint8_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63465,9 +63499,7 @@
 
     PhysicalDeviceIndexTypeUint8FeaturesEXT & operator=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    indexTypeUint8 = rhs.indexTypeUint8;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) );
       return *this;
     }
 
@@ -63538,6 +63570,8 @@
     : inlineUniformBlock( inlineUniformBlock_ ), descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63552,10 +63586,7 @@
 
     PhysicalDeviceInlineUniformBlockFeaturesEXT & operator=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    inlineUniformBlock = rhs.inlineUniformBlock;
-    descriptorBindingInlineUniformBlockUpdateAfterBind = rhs.descriptorBindingInlineUniformBlockUpdateAfterBind;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) );
       return *this;
     }
 
@@ -63634,6 +63665,8 @@
     : maxInlineUniformBlockSize( maxInlineUniformBlockSize_ ), maxPerStageDescriptorInlineUniformBlocks( maxPerStageDescriptorInlineUniformBlocks_ ), maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ ), maxDescriptorSetInlineUniformBlocks( maxDescriptorSetInlineUniformBlocks_ ), maxDescriptorSetUpdateAfterBindInlineUniformBlocks( maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockPropertiesEXT( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63648,13 +63681,7 @@
 
     PhysicalDeviceInlineUniformBlockPropertiesEXT & operator=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxInlineUniformBlockSize = rhs.maxInlineUniformBlockSize;
-    maxPerStageDescriptorInlineUniformBlocks = rhs.maxPerStageDescriptorInlineUniformBlocks;
-    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
-    maxDescriptorSetInlineUniformBlocks = rhs.maxDescriptorSetInlineUniformBlocks;
-    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) );
       return *this;
     }
 
@@ -63721,6 +63748,8 @@
     : rectangularLines( rectangularLines_ ), bresenhamLines( bresenhamLines_ ), smoothLines( smoothLines_ ), stippledRectangularLines( stippledRectangularLines_ ), stippledBresenhamLines( stippledBresenhamLines_ ), stippledSmoothLines( stippledSmoothLines_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63735,14 +63764,7 @@
 
     PhysicalDeviceLineRasterizationFeaturesEXT & operator=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    rectangularLines = rhs.rectangularLines;
-    bresenhamLines = rhs.bresenhamLines;
-    smoothLines = rhs.smoothLines;
-    stippledRectangularLines = rhs.stippledRectangularLines;
-    stippledBresenhamLines = rhs.stippledBresenhamLines;
-    stippledSmoothLines = rhs.stippledSmoothLines;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) );
       return *this;
     }
 
@@ -63853,6 +63875,8 @@
     : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesEXT( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63867,9 +63891,7 @@
 
     PhysicalDeviceLineRasterizationPropertiesEXT & operator=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    lineSubPixelPrecisionBits = rhs.lineSubPixelPrecisionBits;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) );
       return *this;
     }
 
@@ -63928,6 +63950,8 @@
     : maxPerSetDescriptors( maxPerSetDescriptors_ ), maxMemoryAllocationSize( maxMemoryAllocationSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -63942,10 +63966,7 @@
 
     PhysicalDeviceMaintenance3Properties & operator=( PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxPerSetDescriptors = rhs.maxPerSetDescriptors;
-    maxMemoryAllocationSize = rhs.maxMemoryAllocationSize;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMaintenance3Properties ) );
       return *this;
     }
 
@@ -64007,6 +64028,8 @@
     : heapBudget( heapBudget_ ), heapUsage( heapUsage_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64021,10 +64044,7 @@
 
     PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    heapBudget = rhs.heapBudget;
-    heapUsage = rhs.heapUsage;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) );
       return *this;
     }
 
@@ -64085,6 +64105,8 @@
     : memoryPriority( memoryPriority_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64099,9 +64121,7 @@
 
     PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    memoryPriority = rhs.memoryPriority;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) );
       return *this;
     }
 
@@ -64172,6 +64192,8 @@
     : taskShader( taskShader_ ), meshShader( meshShader_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64186,10 +64208,7 @@
 
     PhysicalDeviceMeshShaderFeaturesNV & operator=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    taskShader = rhs.taskShader;
-    meshShader = rhs.meshShader;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
       return *this;
     }
 
@@ -64268,6 +64287,8 @@
     : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ ), maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ ), maxTaskWorkGroupSize( maxTaskWorkGroupSize_ ), maxTaskTotalMemorySize( maxTaskTotalMemorySize_ ), maxTaskOutputCount( maxTaskOutputCount_ ), maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ ), maxMeshWorkGroupSize( maxMeshWorkGroupSize_ ), maxMeshTotalMemorySize( maxMeshTotalMemorySize_ ), maxMeshOutputVertices( maxMeshOutputVertices_ ), maxMeshOutputPrimitives( maxMeshOutputPrimitives_ ), maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ ), meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ ), meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64282,21 +64303,7 @@
 
     PhysicalDeviceMeshShaderPropertiesNV & operator=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxDrawMeshTasksCount = rhs.maxDrawMeshTasksCount;
-    maxTaskWorkGroupInvocations = rhs.maxTaskWorkGroupInvocations;
-    maxTaskWorkGroupSize = rhs.maxTaskWorkGroupSize;
-    maxTaskTotalMemorySize = rhs.maxTaskTotalMemorySize;
-    maxTaskOutputCount = rhs.maxTaskOutputCount;
-    maxMeshWorkGroupInvocations = rhs.maxMeshWorkGroupInvocations;
-    maxMeshWorkGroupSize = rhs.maxMeshWorkGroupSize;
-    maxMeshTotalMemorySize = rhs.maxMeshTotalMemorySize;
-    maxMeshOutputVertices = rhs.maxMeshOutputVertices;
-    maxMeshOutputPrimitives = rhs.maxMeshOutputPrimitives;
-    maxMeshMultiviewViewCount = rhs.maxMeshMultiviewViewCount;
-    meshOutputPerVertexGranularity = rhs.meshOutputPerVertexGranularity;
-    meshOutputPerPrimitiveGranularity = rhs.meshOutputPerPrimitiveGranularity;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
       return *this;
     }
 
@@ -64379,6 +64386,8 @@
     : multiview( multiview_ ), multiviewGeometryShader( multiviewGeometryShader_ ), multiviewTessellationShader( multiviewTessellationShader_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64393,11 +64402,7 @@
 
     PhysicalDeviceMultiviewFeatures & operator=( PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    multiview = rhs.multiview;
-    multiviewGeometryShader = rhs.multiviewGeometryShader;
-    multiviewTessellationShader = rhs.multiviewTessellationShader;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
       return *this;
     }
 
@@ -64485,6 +64490,8 @@
     : perViewPositionAllComponents( perViewPositionAllComponents_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64499,9 +64506,7 @@
 
     PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & operator=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    perViewPositionAllComponents = rhs.perViewPositionAllComponents;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) );
       return *this;
     }
 
@@ -64560,6 +64565,8 @@
     : maxMultiviewViewCount( maxMultiviewViewCount_ ), maxMultiviewInstanceIndex( maxMultiviewInstanceIndex_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64574,10 +64581,7 @@
 
     PhysicalDeviceMultiviewProperties & operator=( PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxMultiviewViewCount = rhs.maxMultiviewViewCount;
-    maxMultiviewInstanceIndex = rhs.maxMultiviewInstanceIndex;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMultiviewProperties ) );
       return *this;
     }
 
@@ -64639,6 +64643,8 @@
     : pciDomain( pciDomain_ ), pciBus( pciBus_ ), pciDevice( pciDevice_ ), pciFunction( pciFunction_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64653,12 +64659,7 @@
 
     PhysicalDevicePCIBusInfoPropertiesEXT & operator=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pciDomain = rhs.pciDomain;
-    pciBus = rhs.pciBus;
-    pciDevice = rhs.pciDevice;
-    pciFunction = rhs.pciFunction;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) );
       return *this;
     }
 
@@ -64723,6 +64724,8 @@
     : performanceCounterQueryPools( performanceCounterQueryPools_ ), performanceCounterMultipleQueryPools( performanceCounterMultipleQueryPools_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevicePerformanceQueryFeaturesKHR( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64737,10 +64740,7 @@
 
     PhysicalDevicePerformanceQueryFeaturesKHR & operator=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    performanceCounterQueryPools = rhs.performanceCounterQueryPools;
-    performanceCounterMultipleQueryPools = rhs.performanceCounterMultipleQueryPools;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevicePerformanceQueryFeaturesKHR ) );
       return *this;
     }
 
@@ -64819,6 +64819,8 @@
     : allowCommandBufferQueryCopies( allowCommandBufferQueryCopies_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevicePerformanceQueryPropertiesKHR( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64833,9 +64835,7 @@
 
     PhysicalDevicePerformanceQueryPropertiesKHR & operator=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    allowCommandBufferQueryCopies = rhs.allowCommandBufferQueryCopies;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevicePerformanceQueryPropertiesKHR ) );
       return *this;
     }
 
@@ -64894,6 +64894,8 @@
     : pipelineCreationCacheControl( pipelineCreationCacheControl_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCreationCacheControlFeaturesEXT( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevicePipelineCreationCacheControlFeaturesEXT( VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64908,9 +64910,7 @@
 
     PhysicalDevicePipelineCreationCacheControlFeaturesEXT & operator=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pipelineCreationCacheControl = rhs.pipelineCreationCacheControl;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevicePipelineCreationCacheControlFeaturesEXT ) );
       return *this;
     }
 
@@ -64981,6 +64981,8 @@
     : pipelineExecutableInfo( pipelineExecutableInfo_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -64995,9 +64997,7 @@
 
     PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & operator=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pipelineExecutableInfo = rhs.pipelineExecutableInfo;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) );
       return *this;
     }
 
@@ -65068,6 +65068,8 @@
     : pointClippingBehavior( pointClippingBehavior_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65082,9 +65084,7 @@
 
     PhysicalDevicePointClippingProperties & operator=( PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pointClippingBehavior = rhs.pointClippingBehavior;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevicePointClippingProperties ) );
       return *this;
     }
 
@@ -65144,6 +65144,8 @@
     : privateData( privateData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePrivateDataFeaturesEXT( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevicePrivateDataFeaturesEXT( VkPhysicalDevicePrivateDataFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65158,9 +65160,7 @@
 
     PhysicalDevicePrivateDataFeaturesEXT & operator=( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    privateData = rhs.privateData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevicePrivateDataFeaturesEXT ) );
       return *this;
     }
 
@@ -65231,6 +65231,8 @@
     : protectedMemory( protectedMemory_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65245,9 +65247,7 @@
 
     PhysicalDeviceProtectedMemoryFeatures & operator=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    protectedMemory = rhs.protectedMemory;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
       return *this;
     }
 
@@ -65318,6 +65318,8 @@
     : protectedNoFault( protectedNoFault_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65332,9 +65334,7 @@
 
     PhysicalDeviceProtectedMemoryProperties & operator=( PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    protectedNoFault = rhs.protectedNoFault;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) );
       return *this;
     }
 
@@ -65393,6 +65393,8 @@
     : maxPushDescriptors( maxPushDescriptors_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorPropertiesKHR( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65407,9 +65409,7 @@
 
     PhysicalDevicePushDescriptorPropertiesKHR & operator=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxPushDescriptors = rhs.maxPushDescriptors;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
       return *this;
     }
 
@@ -65469,6 +65469,8 @@
     : rayTracing( rayTracing_ ), rayTracingShaderGroupHandleCaptureReplay( rayTracingShaderGroupHandleCaptureReplay_ ), rayTracingShaderGroupHandleCaptureReplayMixed( rayTracingShaderGroupHandleCaptureReplayMixed_ ), rayTracingAccelerationStructureCaptureReplay( rayTracingAccelerationStructureCaptureReplay_ ), rayTracingIndirectTraceRays( rayTracingIndirectTraceRays_ ), rayTracingIndirectAccelerationStructureBuild( rayTracingIndirectAccelerationStructureBuild_ ), rayTracingHostAccelerationStructureCommands( rayTracingHostAccelerationStructureCommands_ ), rayQuery( rayQuery_ ), rayTracingPrimitiveCulling( rayTracingPrimitiveCulling_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingFeaturesKHR( PhysicalDeviceRayTracingFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceRayTracingFeaturesKHR( VkPhysicalDeviceRayTracingFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65483,17 +65485,7 @@
 
     PhysicalDeviceRayTracingFeaturesKHR & operator=( PhysicalDeviceRayTracingFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    rayTracing = rhs.rayTracing;
-    rayTracingShaderGroupHandleCaptureReplay = rhs.rayTracingShaderGroupHandleCaptureReplay;
-    rayTracingShaderGroupHandleCaptureReplayMixed = rhs.rayTracingShaderGroupHandleCaptureReplayMixed;
-    rayTracingAccelerationStructureCaptureReplay = rhs.rayTracingAccelerationStructureCaptureReplay;
-    rayTracingIndirectTraceRays = rhs.rayTracingIndirectTraceRays;
-    rayTracingIndirectAccelerationStructureBuild = rhs.rayTracingIndirectAccelerationStructureBuild;
-    rayTracingHostAccelerationStructureCommands = rhs.rayTracingHostAccelerationStructureCommands;
-    rayQuery = rhs.rayQuery;
-    rayTracingPrimitiveCulling = rhs.rayTracingPrimitiveCulling;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceRayTracingFeaturesKHR ) );
       return *this;
     }
 
@@ -65630,6 +65622,8 @@
     : shaderGroupHandleSize( shaderGroupHandleSize_ ), maxRecursionDepth( maxRecursionDepth_ ), maxShaderGroupStride( maxShaderGroupStride_ ), shaderGroupBaseAlignment( shaderGroupBaseAlignment_ ), maxGeometryCount( maxGeometryCount_ ), maxInstanceCount( maxInstanceCount_ ), maxPrimitiveCount( maxPrimitiveCount_ ), maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ ), shaderGroupHandleCaptureReplaySize( shaderGroupHandleCaptureReplaySize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesKHR( PhysicalDeviceRayTracingPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceRayTracingPropertiesKHR( VkPhysicalDeviceRayTracingPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65644,17 +65638,7 @@
 
     PhysicalDeviceRayTracingPropertiesKHR & operator=( PhysicalDeviceRayTracingPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderGroupHandleSize = rhs.shaderGroupHandleSize;
-    maxRecursionDepth = rhs.maxRecursionDepth;
-    maxShaderGroupStride = rhs.maxShaderGroupStride;
-    shaderGroupBaseAlignment = rhs.shaderGroupBaseAlignment;
-    maxGeometryCount = rhs.maxGeometryCount;
-    maxInstanceCount = rhs.maxInstanceCount;
-    maxPrimitiveCount = rhs.maxPrimitiveCount;
-    maxDescriptorSetAccelerationStructures = rhs.maxDescriptorSetAccelerationStructures;
-    shaderGroupHandleCaptureReplaySize = rhs.shaderGroupHandleCaptureReplaySize;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceRayTracingPropertiesKHR ) );
       return *this;
     }
 
@@ -65730,6 +65714,8 @@
     : shaderGroupHandleSize( shaderGroupHandleSize_ ), maxRecursionDepth( maxRecursionDepth_ ), maxShaderGroupStride( maxShaderGroupStride_ ), shaderGroupBaseAlignment( shaderGroupBaseAlignment_ ), maxGeometryCount( maxGeometryCount_ ), maxInstanceCount( maxInstanceCount_ ), maxTriangleCount( maxTriangleCount_ ), maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65744,16 +65730,7 @@
 
     PhysicalDeviceRayTracingPropertiesNV & operator=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderGroupHandleSize = rhs.shaderGroupHandleSize;
-    maxRecursionDepth = rhs.maxRecursionDepth;
-    maxShaderGroupStride = rhs.maxShaderGroupStride;
-    shaderGroupBaseAlignment = rhs.shaderGroupBaseAlignment;
-    maxGeometryCount = rhs.maxGeometryCount;
-    maxInstanceCount = rhs.maxInstanceCount;
-    maxTriangleCount = rhs.maxTriangleCount;
-    maxDescriptorSetAccelerationStructures = rhs.maxDescriptorSetAccelerationStructures;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
       return *this;
     }
 
@@ -65826,6 +65803,8 @@
     : representativeFragmentTest( representativeFragmentTest_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65840,9 +65819,7 @@
 
     PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    representativeFragmentTest = rhs.representativeFragmentTest;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
       return *this;
     }
 
@@ -65913,6 +65890,8 @@
     : robustBufferAccess2( robustBufferAccess2_ ), robustImageAccess2( robustImageAccess2_ ), nullDescriptor( nullDescriptor_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesEXT( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceRobustness2FeaturesEXT( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -65927,11 +65906,7 @@
 
     PhysicalDeviceRobustness2FeaturesEXT & operator=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    robustBufferAccess2 = rhs.robustBufferAccess2;
-    robustImageAccess2 = rhs.robustImageAccess2;
-    nullDescriptor = rhs.nullDescriptor;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceRobustness2FeaturesEXT ) );
       return *this;
     }
 
@@ -66018,6 +65993,8 @@
     : robustStorageBufferAccessSizeAlignment( robustStorageBufferAccessSizeAlignment_ ), robustUniformBufferAccessSizeAlignment( robustUniformBufferAccessSizeAlignment_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesEXT( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceRobustness2PropertiesEXT( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66032,10 +66009,7 @@
 
     PhysicalDeviceRobustness2PropertiesEXT & operator=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    robustStorageBufferAccessSizeAlignment = rhs.robustStorageBufferAccessSizeAlignment;
-    robustUniformBufferAccessSizeAlignment = rhs.robustUniformBufferAccessSizeAlignment;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceRobustness2PropertiesEXT ) );
       return *this;
     }
 
@@ -66096,6 +66070,8 @@
     : sampleLocationSampleCounts( sampleLocationSampleCounts_ ), maxSampleLocationGridSize( maxSampleLocationGridSize_ ), sampleLocationCoordinateRange( sampleLocationCoordinateRange_ ), sampleLocationSubPixelBits( sampleLocationSubPixelBits_ ), variableSampleLocations( variableSampleLocations_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66110,13 +66086,7 @@
 
     PhysicalDeviceSampleLocationsPropertiesEXT & operator=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    sampleLocationSampleCounts = rhs.sampleLocationSampleCounts;
-    maxSampleLocationGridSize = rhs.maxSampleLocationGridSize;
-    sampleLocationCoordinateRange = rhs.sampleLocationCoordinateRange;
-    sampleLocationSubPixelBits = rhs.sampleLocationSubPixelBits;
-    variableSampleLocations = rhs.variableSampleLocations;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) );
       return *this;
     }
 
@@ -66183,6 +66153,8 @@
     : filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ ), filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSamplerFilterMinmaxProperties( VkPhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66197,10 +66169,7 @@
 
     PhysicalDeviceSamplerFilterMinmaxProperties & operator=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    filterMinmaxSingleComponentFormats = rhs.filterMinmaxSingleComponentFormats;
-    filterMinmaxImageComponentMapping = rhs.filterMinmaxImageComponentMapping;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSamplerFilterMinmaxProperties ) );
       return *this;
     }
 
@@ -66262,6 +66231,8 @@
     : samplerYcbcrConversion( samplerYcbcrConversion_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66276,9 +66247,7 @@
 
     PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    samplerYcbcrConversion = rhs.samplerYcbcrConversion;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) );
       return *this;
     }
 
@@ -66350,6 +66319,8 @@
     : scalarBlockLayout( scalarBlockLayout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceScalarBlockLayoutFeatures( VkPhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66364,9 +66335,7 @@
 
     PhysicalDeviceScalarBlockLayoutFeatures & operator=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    scalarBlockLayout = rhs.scalarBlockLayout;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeatures ) );
       return *this;
     }
 
@@ -66438,6 +66407,8 @@
     : separateDepthStencilLayouts( separateDepthStencilLayouts_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeatures( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSeparateDepthStencilLayoutsFeatures( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66452,9 +66423,7 @@
 
     PhysicalDeviceSeparateDepthStencilLayoutsFeatures & operator=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    separateDepthStencilLayouts = rhs.separateDepthStencilLayouts;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeatures ) );
       return *this;
     }
 
@@ -66526,6 +66495,8 @@
     : shaderBufferFloat32Atomics( shaderBufferFloat32Atomics_ ), shaderBufferFloat32AtomicAdd( shaderBufferFloat32AtomicAdd_ ), shaderBufferFloat64Atomics( shaderBufferFloat64Atomics_ ), shaderBufferFloat64AtomicAdd( shaderBufferFloat64AtomicAdd_ ), shaderSharedFloat32Atomics( shaderSharedFloat32Atomics_ ), shaderSharedFloat32AtomicAdd( shaderSharedFloat32AtomicAdd_ ), shaderSharedFloat64Atomics( shaderSharedFloat64Atomics_ ), shaderSharedFloat64AtomicAdd( shaderSharedFloat64AtomicAdd_ ), shaderImageFloat32Atomics( shaderImageFloat32Atomics_ ), shaderImageFloat32AtomicAdd( shaderImageFloat32AtomicAdd_ ), sparseImageFloat32Atomics( sparseImageFloat32Atomics_ ), sparseImageFloat32AtomicAdd( sparseImageFloat32AtomicAdd_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloatFeaturesEXT( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderAtomicFloatFeaturesEXT( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66540,20 +66511,7 @@
 
     PhysicalDeviceShaderAtomicFloatFeaturesEXT & operator=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderBufferFloat32Atomics = rhs.shaderBufferFloat32Atomics;
-    shaderBufferFloat32AtomicAdd = rhs.shaderBufferFloat32AtomicAdd;
-    shaderBufferFloat64Atomics = rhs.shaderBufferFloat64Atomics;
-    shaderBufferFloat64AtomicAdd = rhs.shaderBufferFloat64AtomicAdd;
-    shaderSharedFloat32Atomics = rhs.shaderSharedFloat32Atomics;
-    shaderSharedFloat32AtomicAdd = rhs.shaderSharedFloat32AtomicAdd;
-    shaderSharedFloat64Atomics = rhs.shaderSharedFloat64Atomics;
-    shaderSharedFloat64AtomicAdd = rhs.shaderSharedFloat64AtomicAdd;
-    shaderImageFloat32Atomics = rhs.shaderImageFloat32Atomics;
-    shaderImageFloat32AtomicAdd = rhs.shaderImageFloat32AtomicAdd;
-    sparseImageFloat32Atomics = rhs.sparseImageFloat32Atomics;
-    sparseImageFloat32AtomicAdd = rhs.sparseImageFloat32AtomicAdd;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderAtomicFloatFeaturesEXT ) );
       return *this;
     }
 
@@ -66712,6 +66670,8 @@
     : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ ), shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( PhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderAtomicInt64Features( VkPhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66726,10 +66686,7 @@
 
     PhysicalDeviceShaderAtomicInt64Features & operator=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderBufferInt64Atomics = rhs.shaderBufferInt64Atomics;
-    shaderSharedInt64Atomics = rhs.shaderSharedInt64Atomics;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderAtomicInt64Features ) );
       return *this;
     }
 
@@ -66809,6 +66766,8 @@
     : shaderSubgroupClock( shaderSubgroupClock_ ), shaderDeviceClock( shaderDeviceClock_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66823,10 +66782,7 @@
 
     PhysicalDeviceShaderClockFeaturesKHR & operator=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderSubgroupClock = rhs.shaderSubgroupClock;
-    shaderDeviceClock = rhs.shaderDeviceClock;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderClockFeaturesKHR ) );
       return *this;
     }
 
@@ -66905,6 +66861,8 @@
     : shaderCoreFeatures( shaderCoreFeatures_ ), activeComputeUnitCount( activeComputeUnitCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66919,10 +66877,7 @@
 
     PhysicalDeviceShaderCoreProperties2AMD & operator=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderCoreFeatures = rhs.shaderCoreFeatures;
-    activeComputeUnitCount = rhs.activeComputeUnitCount;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderCoreProperties2AMD ) );
       return *this;
     }
 
@@ -66983,6 +66938,8 @@
     : 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_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -66997,22 +66954,7 @@
 
     PhysicalDeviceShaderCorePropertiesAMD & operator=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderEngineCount = rhs.shaderEngineCount;
-    shaderArraysPerEngineCount = rhs.shaderArraysPerEngineCount;
-    computeUnitsPerShaderArray = rhs.computeUnitsPerShaderArray;
-    simdPerComputeUnit = rhs.simdPerComputeUnit;
-    wavefrontsPerSimd = rhs.wavefrontsPerSimd;
-    wavefrontSize = rhs.wavefrontSize;
-    sgprsPerSimd = rhs.sgprsPerSimd;
-    minSgprAllocation = rhs.minSgprAllocation;
-    maxSgprAllocation = rhs.maxSgprAllocation;
-    sgprAllocationGranularity = rhs.sgprAllocationGranularity;
-    vgprsPerSimd = rhs.vgprsPerSimd;
-    minVgprAllocation = rhs.minVgprAllocation;
-    maxVgprAllocation = rhs.maxVgprAllocation;
-    vgprAllocationGranularity = rhs.vgprAllocationGranularity;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderCorePropertiesAMD ) );
       return *this;
     }
 
@@ -67097,6 +67039,8 @@
     : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67111,9 +67055,7 @@
 
     PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & operator=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderDemoteToHelperInvocation = rhs.shaderDemoteToHelperInvocation;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) );
       return *this;
     }
 
@@ -67184,6 +67126,8 @@
     : shaderDrawParameters( shaderDrawParameters_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67198,9 +67142,7 @@
 
     PhysicalDeviceShaderDrawParametersFeatures & operator=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderDrawParameters = rhs.shaderDrawParameters;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderDrawParametersFeatures ) );
       return *this;
     }
 
@@ -67272,6 +67214,8 @@
     : shaderFloat16( shaderFloat16_ ), shaderInt8( shaderInt8_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8Features( PhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderFloat16Int8Features( VkPhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67286,10 +67230,7 @@
 
     PhysicalDeviceShaderFloat16Int8Features & operator=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderFloat16 = rhs.shaderFloat16;
-    shaderInt8 = rhs.shaderInt8;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderFloat16Int8Features ) );
       return *this;
     }
 
@@ -67370,6 +67311,8 @@
     : imageFootprint( imageFootprint_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67384,9 +67327,7 @@
 
     PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    imageFootprint = rhs.imageFootprint;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
       return *this;
     }
 
@@ -67457,6 +67398,8 @@
     : shaderIntegerFunctions2( shaderIntegerFunctions2_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67471,9 +67414,7 @@
 
     PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & operator=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderIntegerFunctions2 = rhs.shaderIntegerFunctions2;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) );
       return *this;
     }
 
@@ -67544,6 +67485,8 @@
     : shaderSMBuiltins( shaderSMBuiltins_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67558,9 +67501,7 @@
 
     PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderSMBuiltins = rhs.shaderSMBuiltins;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) );
       return *this;
     }
 
@@ -67631,6 +67572,8 @@
     : shaderSMCount( shaderSMCount_ ), shaderWarpsPerSM( shaderWarpsPerSM_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsPropertiesNV( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67645,10 +67588,7 @@
 
     PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderSMCount = rhs.shaderSMCount;
-    shaderWarpsPerSM = rhs.shaderWarpsPerSM;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) );
       return *this;
     }
 
@@ -67709,6 +67649,8 @@
     : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeatures( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShaderSubgroupExtendedTypesFeatures( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67723,9 +67665,7 @@
 
     PhysicalDeviceShaderSubgroupExtendedTypesFeatures & operator=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shaderSubgroupExtendedTypes = rhs.shaderSubgroupExtendedTypes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeatures ) );
       return *this;
     }
 
@@ -67797,6 +67737,8 @@
     : shadingRateImage( shadingRateImage_ ), shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67811,10 +67753,7 @@
 
     PhysicalDeviceShadingRateImageFeaturesNV & operator=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shadingRateImage = rhs.shadingRateImage;
-    shadingRateCoarseSampleOrder = rhs.shadingRateCoarseSampleOrder;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
       return *this;
     }
 
@@ -67893,6 +67832,8 @@
     : shadingRateTexelSize( shadingRateTexelSize_ ), shadingRatePaletteSize( shadingRatePaletteSize_ ), shadingRateMaxCoarseSamples( shadingRateMaxCoarseSamples_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67907,11 +67848,7 @@
 
     PhysicalDeviceShadingRateImagePropertiesNV & operator=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shadingRateTexelSize = rhs.shadingRateTexelSize;
-    shadingRatePaletteSize = rhs.shadingRatePaletteSize;
-    shadingRateMaxCoarseSamples = rhs.shadingRateMaxCoarseSamples;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) );
       return *this;
     }
 
@@ -67974,6 +67911,8 @@
     : subgroupSize( subgroupSize_ ), supportedStages( supportedStages_ ), supportedOperations( supportedOperations_ ), quadOperationsInAllStages( quadOperationsInAllStages_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -67988,12 +67927,7 @@
 
     PhysicalDeviceSubgroupProperties & operator=( PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    subgroupSize = rhs.subgroupSize;
-    supportedStages = rhs.supportedStages;
-    supportedOperations = rhs.supportedOperations;
-    quadOperationsInAllStages = rhs.quadOperationsInAllStages;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSubgroupProperties ) );
       return *this;
     }
 
@@ -68058,6 +67992,8 @@
     : subgroupSizeControl( subgroupSizeControl_ ), computeFullSubgroups( computeFullSubgroups_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68072,10 +68008,7 @@
 
     PhysicalDeviceSubgroupSizeControlFeaturesEXT & operator=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    subgroupSizeControl = rhs.subgroupSizeControl;
-    computeFullSubgroups = rhs.computeFullSubgroups;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) );
       return *this;
     }
 
@@ -68154,6 +68087,8 @@
     : minSubgroupSize( minSubgroupSize_ ), maxSubgroupSize( maxSubgroupSize_ ), maxComputeWorkgroupSubgroups( maxComputeWorkgroupSubgroups_ ), requiredSubgroupSizeStages( requiredSubgroupSizeStages_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlPropertiesEXT( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68168,12 +68103,7 @@
 
     PhysicalDeviceSubgroupSizeControlPropertiesEXT & operator=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    minSubgroupSize = rhs.minSubgroupSize;
-    maxSubgroupSize = rhs.maxSubgroupSize;
-    maxComputeWorkgroupSubgroups = rhs.maxComputeWorkgroupSubgroups;
-    requiredSubgroupSizeStages = rhs.requiredSubgroupSizeStages;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) );
       return *this;
     }
 
@@ -68238,6 +68168,8 @@
     : texelBufferAlignment( texelBufferAlignment_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68252,9 +68184,7 @@
 
     PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    texelBufferAlignment = rhs.texelBufferAlignment;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) );
       return *this;
     }
 
@@ -68325,6 +68255,8 @@
     : storageTexelBufferOffsetAlignmentBytes( storageTexelBufferOffsetAlignmentBytes_ ), storageTexelBufferOffsetSingleTexelAlignment( storageTexelBufferOffsetSingleTexelAlignment_ ), uniformTexelBufferOffsetAlignmentBytes( uniformTexelBufferOffsetAlignmentBytes_ ), uniformTexelBufferOffsetSingleTexelAlignment( uniformTexelBufferOffsetSingleTexelAlignment_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentPropertiesEXT( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68339,12 +68271,7 @@
 
     PhysicalDeviceTexelBufferAlignmentPropertiesEXT & operator=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    storageTexelBufferOffsetAlignmentBytes = rhs.storageTexelBufferOffsetAlignmentBytes;
-    storageTexelBufferOffsetSingleTexelAlignment = rhs.storageTexelBufferOffsetSingleTexelAlignment;
-    uniformTexelBufferOffsetAlignmentBytes = rhs.uniformTexelBufferOffsetAlignmentBytes;
-    uniformTexelBufferOffsetSingleTexelAlignment = rhs.uniformTexelBufferOffsetSingleTexelAlignment;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) );
       return *this;
     }
 
@@ -68409,6 +68336,8 @@
     : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68423,9 +68352,7 @@
 
     PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & operator=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    textureCompressionASTC_HDR = rhs.textureCompressionASTC_HDR;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) );
       return *this;
     }
 
@@ -68496,6 +68423,8 @@
     : timelineSemaphore( timelineSemaphore_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceTimelineSemaphoreFeatures( VkPhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68510,9 +68439,7 @@
 
     PhysicalDeviceTimelineSemaphoreFeatures & operator=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    timelineSemaphore = rhs.timelineSemaphore;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceTimelineSemaphoreFeatures ) );
       return *this;
     }
 
@@ -68584,6 +68511,8 @@
     : maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceTimelineSemaphoreProperties( VkPhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68598,9 +68527,7 @@
 
     PhysicalDeviceTimelineSemaphoreProperties & operator=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxTimelineSemaphoreValueDifference = rhs.maxTimelineSemaphoreValueDifference;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceTimelineSemaphoreProperties ) );
       return *this;
     }
 
@@ -68660,6 +68587,8 @@
     : transformFeedback( transformFeedback_ ), geometryStreams( geometryStreams_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68674,10 +68603,7 @@
 
     PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    transformFeedback = rhs.transformFeedback;
-    geometryStreams = rhs.geometryStreams;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
       return *this;
     }
 
@@ -68756,6 +68682,8 @@
     : maxTransformFeedbackStreams( maxTransformFeedbackStreams_ ), maxTransformFeedbackBuffers( maxTransformFeedbackBuffers_ ), maxTransformFeedbackBufferSize( maxTransformFeedbackBufferSize_ ), maxTransformFeedbackStreamDataSize( maxTransformFeedbackStreamDataSize_ ), maxTransformFeedbackBufferDataSize( maxTransformFeedbackBufferDataSize_ ), maxTransformFeedbackBufferDataStride( maxTransformFeedbackBufferDataStride_ ), transformFeedbackQueries( transformFeedbackQueries_ ), transformFeedbackStreamsLinesTriangles( transformFeedbackStreamsLinesTriangles_ ), transformFeedbackRasterizationStreamSelect( transformFeedbackRasterizationStreamSelect_ ), transformFeedbackDraw( transformFeedbackDraw_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68770,18 +68698,7 @@
 
     PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxTransformFeedbackStreams = rhs.maxTransformFeedbackStreams;
-    maxTransformFeedbackBuffers = rhs.maxTransformFeedbackBuffers;
-    maxTransformFeedbackBufferSize = rhs.maxTransformFeedbackBufferSize;
-    maxTransformFeedbackStreamDataSize = rhs.maxTransformFeedbackStreamDataSize;
-    maxTransformFeedbackBufferDataSize = rhs.maxTransformFeedbackBufferDataSize;
-    maxTransformFeedbackBufferDataStride = rhs.maxTransformFeedbackBufferDataStride;
-    transformFeedbackQueries = rhs.transformFeedbackQueries;
-    transformFeedbackStreamsLinesTriangles = rhs.transformFeedbackStreamsLinesTriangles;
-    transformFeedbackRasterizationStreamSelect = rhs.transformFeedbackRasterizationStreamSelect;
-    transformFeedbackDraw = rhs.transformFeedbackDraw;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) );
       return *this;
     }
 
@@ -68858,6 +68775,8 @@
     : uniformBufferStandardLayout( uniformBufferStandardLayout_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeatures( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceUniformBufferStandardLayoutFeatures( VkPhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68872,9 +68791,7 @@
 
     PhysicalDeviceUniformBufferStandardLayoutFeatures & operator=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    uniformBufferStandardLayout = rhs.uniformBufferStandardLayout;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceUniformBufferStandardLayoutFeatures ) );
       return *this;
     }
 
@@ -68946,6 +68863,8 @@
     : variablePointersStorageBuffer( variablePointersStorageBuffer_ ), variablePointers( variablePointers_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -68960,10 +68879,7 @@
 
     PhysicalDeviceVariablePointersFeatures & operator=( PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    variablePointersStorageBuffer = rhs.variablePointersStorageBuffer;
-    variablePointers = rhs.variablePointers;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceVariablePointersFeatures ) );
       return *this;
     }
 
@@ -69045,6 +68961,8 @@
     : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ ), vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -69059,10 +68977,7 @@
 
     PhysicalDeviceVertexAttributeDivisorFeaturesEXT & operator=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    vertexAttributeInstanceRateDivisor = rhs.vertexAttributeInstanceRateDivisor;
-    vertexAttributeInstanceRateZeroDivisor = rhs.vertexAttributeInstanceRateZeroDivisor;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
       return *this;
     }
 
@@ -69141,6 +69056,8 @@
     : maxVertexAttribDivisor( maxVertexAttribDivisor_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorPropertiesEXT( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -69155,9 +69072,7 @@
 
     PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    maxVertexAttribDivisor = rhs.maxVertexAttribDivisor;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) );
       return *this;
     }
 
@@ -69216,6 +69131,8 @@
     : storageBuffer16BitAccess( storageBuffer16BitAccess_ ), uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ), storagePushConstant16( storagePushConstant16_ ), storageInputOutput16( storageInputOutput16_ ), multiview( multiview_ ), multiviewGeometryShader( multiviewGeometryShader_ ), multiviewTessellationShader( multiviewTessellationShader_ ), variablePointersStorageBuffer( variablePointersStorageBuffer_ ), variablePointers( variablePointers_ ), protectedMemory( protectedMemory_ ), samplerYcbcrConversion( samplerYcbcrConversion_ ), shaderDrawParameters( shaderDrawParameters_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( PhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceVulkan11Features( VkPhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -69230,20 +69147,7 @@
 
     PhysicalDeviceVulkan11Features & operator=( PhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    storageBuffer16BitAccess = rhs.storageBuffer16BitAccess;
-    uniformAndStorageBuffer16BitAccess = rhs.uniformAndStorageBuffer16BitAccess;
-    storagePushConstant16 = rhs.storagePushConstant16;
-    storageInputOutput16 = rhs.storageInputOutput16;
-    multiview = rhs.multiview;
-    multiviewGeometryShader = rhs.multiviewGeometryShader;
-    multiviewTessellationShader = rhs.multiviewTessellationShader;
-    variablePointersStorageBuffer = rhs.variablePointersStorageBuffer;
-    variablePointers = rhs.variablePointers;
-    protectedMemory = rhs.protectedMemory;
-    samplerYcbcrConversion = rhs.samplerYcbcrConversion;
-    shaderDrawParameters = rhs.shaderDrawParameters;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceVulkan11Features ) );
       return *this;
     }
 
@@ -69402,6 +69306,8 @@
     : deviceUUID( deviceUUID_ ), driverUUID( driverUUID_ ), deviceLUID( deviceLUID_ ), deviceNodeMask( deviceNodeMask_ ), deviceLUIDValid( deviceLUIDValid_ ), subgroupSize( subgroupSize_ ), subgroupSupportedStages( subgroupSupportedStages_ ), subgroupSupportedOperations( subgroupSupportedOperations_ ), subgroupQuadOperationsInAllStages( subgroupQuadOperationsInAllStages_ ), pointClippingBehavior( pointClippingBehavior_ ), maxMultiviewViewCount( maxMultiviewViewCount_ ), maxMultiviewInstanceIndex( maxMultiviewInstanceIndex_ ), protectedNoFault( protectedNoFault_ ), maxPerSetDescriptors( maxPerSetDescriptors_ ), maxMemoryAllocationSize( maxMemoryAllocationSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( PhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceVulkan11Properties( VkPhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -69416,23 +69322,7 @@
 
     PhysicalDeviceVulkan11Properties & operator=( PhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    deviceUUID = rhs.deviceUUID;
-    driverUUID = rhs.driverUUID;
-    deviceLUID = rhs.deviceLUID;
-    deviceNodeMask = rhs.deviceNodeMask;
-    deviceLUIDValid = rhs.deviceLUIDValid;
-    subgroupSize = rhs.subgroupSize;
-    subgroupSupportedStages = rhs.subgroupSupportedStages;
-    subgroupSupportedOperations = rhs.subgroupSupportedOperations;
-    subgroupQuadOperationsInAllStages = rhs.subgroupQuadOperationsInAllStages;
-    pointClippingBehavior = rhs.pointClippingBehavior;
-    maxMultiviewViewCount = rhs.maxMultiviewViewCount;
-    maxMultiviewInstanceIndex = rhs.maxMultiviewInstanceIndex;
-    protectedNoFault = rhs.protectedNoFault;
-    maxPerSetDescriptors = rhs.maxPerSetDescriptors;
-    maxMemoryAllocationSize = rhs.maxMemoryAllocationSize;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceVulkan11Properties ) );
       return *this;
     }
 
@@ -69519,6 +69409,8 @@
     : samplerMirrorClampToEdge( samplerMirrorClampToEdge_ ), drawIndirectCount( drawIndirectCount_ ), storageBuffer8BitAccess( storageBuffer8BitAccess_ ), uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ ), storagePushConstant8( storagePushConstant8_ ), shaderBufferInt64Atomics( shaderBufferInt64Atomics_ ), shaderSharedInt64Atomics( shaderSharedInt64Atomics_ ), shaderFloat16( shaderFloat16_ ), shaderInt8( shaderInt8_ ), descriptorIndexing( descriptorIndexing_ ), 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_ ), samplerFilterMinmax( samplerFilterMinmax_ ), scalarBlockLayout( scalarBlockLayout_ ), imagelessFramebuffer( imagelessFramebuffer_ ), uniformBufferStandardLayout( uniformBufferStandardLayout_ ), shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ ), separateDepthStencilLayouts( separateDepthStencilLayouts_ ), hostQueryReset( hostQueryReset_ ), timelineSemaphore( timelineSemaphore_ ), bufferDeviceAddress( bufferDeviceAddress_ ), bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ), bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ ), vulkanMemoryModel( vulkanMemoryModel_ ), vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ ), vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ ), shaderOutputViewportIndex( shaderOutputViewportIndex_ ), shaderOutputLayer( shaderOutputLayer_ ), subgroupBroadcastDynamicId( subgroupBroadcastDynamicId_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( PhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceVulkan12Features( VkPhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -69533,55 +69425,7 @@
 
     PhysicalDeviceVulkan12Features & operator=( PhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    samplerMirrorClampToEdge = rhs.samplerMirrorClampToEdge;
-    drawIndirectCount = rhs.drawIndirectCount;
-    storageBuffer8BitAccess = rhs.storageBuffer8BitAccess;
-    uniformAndStorageBuffer8BitAccess = rhs.uniformAndStorageBuffer8BitAccess;
-    storagePushConstant8 = rhs.storagePushConstant8;
-    shaderBufferInt64Atomics = rhs.shaderBufferInt64Atomics;
-    shaderSharedInt64Atomics = rhs.shaderSharedInt64Atomics;
-    shaderFloat16 = rhs.shaderFloat16;
-    shaderInt8 = rhs.shaderInt8;
-    descriptorIndexing = rhs.descriptorIndexing;
-    shaderInputAttachmentArrayDynamicIndexing = rhs.shaderInputAttachmentArrayDynamicIndexing;
-    shaderUniformTexelBufferArrayDynamicIndexing = rhs.shaderUniformTexelBufferArrayDynamicIndexing;
-    shaderStorageTexelBufferArrayDynamicIndexing = rhs.shaderStorageTexelBufferArrayDynamicIndexing;
-    shaderUniformBufferArrayNonUniformIndexing = rhs.shaderUniformBufferArrayNonUniformIndexing;
-    shaderSampledImageArrayNonUniformIndexing = rhs.shaderSampledImageArrayNonUniformIndexing;
-    shaderStorageBufferArrayNonUniformIndexing = rhs.shaderStorageBufferArrayNonUniformIndexing;
-    shaderStorageImageArrayNonUniformIndexing = rhs.shaderStorageImageArrayNonUniformIndexing;
-    shaderInputAttachmentArrayNonUniformIndexing = rhs.shaderInputAttachmentArrayNonUniformIndexing;
-    shaderUniformTexelBufferArrayNonUniformIndexing = rhs.shaderUniformTexelBufferArrayNonUniformIndexing;
-    shaderStorageTexelBufferArrayNonUniformIndexing = rhs.shaderStorageTexelBufferArrayNonUniformIndexing;
-    descriptorBindingUniformBufferUpdateAfterBind = rhs.descriptorBindingUniformBufferUpdateAfterBind;
-    descriptorBindingSampledImageUpdateAfterBind = rhs.descriptorBindingSampledImageUpdateAfterBind;
-    descriptorBindingStorageImageUpdateAfterBind = rhs.descriptorBindingStorageImageUpdateAfterBind;
-    descriptorBindingStorageBufferUpdateAfterBind = rhs.descriptorBindingStorageBufferUpdateAfterBind;
-    descriptorBindingUniformTexelBufferUpdateAfterBind = rhs.descriptorBindingUniformTexelBufferUpdateAfterBind;
-    descriptorBindingStorageTexelBufferUpdateAfterBind = rhs.descriptorBindingStorageTexelBufferUpdateAfterBind;
-    descriptorBindingUpdateUnusedWhilePending = rhs.descriptorBindingUpdateUnusedWhilePending;
-    descriptorBindingPartiallyBound = rhs.descriptorBindingPartiallyBound;
-    descriptorBindingVariableDescriptorCount = rhs.descriptorBindingVariableDescriptorCount;
-    runtimeDescriptorArray = rhs.runtimeDescriptorArray;
-    samplerFilterMinmax = rhs.samplerFilterMinmax;
-    scalarBlockLayout = rhs.scalarBlockLayout;
-    imagelessFramebuffer = rhs.imagelessFramebuffer;
-    uniformBufferStandardLayout = rhs.uniformBufferStandardLayout;
-    shaderSubgroupExtendedTypes = rhs.shaderSubgroupExtendedTypes;
-    separateDepthStencilLayouts = rhs.separateDepthStencilLayouts;
-    hostQueryReset = rhs.hostQueryReset;
-    timelineSemaphore = rhs.timelineSemaphore;
-    bufferDeviceAddress = rhs.bufferDeviceAddress;
-    bufferDeviceAddressCaptureReplay = rhs.bufferDeviceAddressCaptureReplay;
-    bufferDeviceAddressMultiDevice = rhs.bufferDeviceAddressMultiDevice;
-    vulkanMemoryModel = rhs.vulkanMemoryModel;
-    vulkanMemoryModelDeviceScope = rhs.vulkanMemoryModelDeviceScope;
-    vulkanMemoryModelAvailabilityVisibilityChains = rhs.vulkanMemoryModelAvailabilityVisibilityChains;
-    shaderOutputViewportIndex = rhs.shaderOutputViewportIndex;
-    shaderOutputLayer = rhs.shaderOutputLayer;
-    subgroupBroadcastDynamicId = rhs.subgroupBroadcastDynamicId;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceVulkan12Features ) );
       return *this;
     }
 
@@ -70020,6 +69864,8 @@
     : driverID( driverID_ ), driverName( driverName_ ), driverInfo( driverInfo_ ), conformanceVersion( conformanceVersion_ ), 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_ ), 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_ ), supportedDepthResolveModes( supportedDepthResolveModes_ ), supportedStencilResolveModes( supportedStencilResolveModes_ ), independentResolveNone( independentResolveNone_ ), independentResolve( independentResolve_ ), filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ ), filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ ), maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ ), framebufferIntegerColorSampleCounts( framebufferIntegerColorSampleCounts_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Properties( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceVulkan12Properties( VkPhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70034,60 +69880,7 @@
 
     PhysicalDeviceVulkan12Properties & operator=( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    driverID = rhs.driverID;
-    driverName = rhs.driverName;
-    driverInfo = rhs.driverInfo;
-    conformanceVersion = rhs.conformanceVersion;
-    denormBehaviorIndependence = rhs.denormBehaviorIndependence;
-    roundingModeIndependence = rhs.roundingModeIndependence;
-    shaderSignedZeroInfNanPreserveFloat16 = rhs.shaderSignedZeroInfNanPreserveFloat16;
-    shaderSignedZeroInfNanPreserveFloat32 = rhs.shaderSignedZeroInfNanPreserveFloat32;
-    shaderSignedZeroInfNanPreserveFloat64 = rhs.shaderSignedZeroInfNanPreserveFloat64;
-    shaderDenormPreserveFloat16 = rhs.shaderDenormPreserveFloat16;
-    shaderDenormPreserveFloat32 = rhs.shaderDenormPreserveFloat32;
-    shaderDenormPreserveFloat64 = rhs.shaderDenormPreserveFloat64;
-    shaderDenormFlushToZeroFloat16 = rhs.shaderDenormFlushToZeroFloat16;
-    shaderDenormFlushToZeroFloat32 = rhs.shaderDenormFlushToZeroFloat32;
-    shaderDenormFlushToZeroFloat64 = rhs.shaderDenormFlushToZeroFloat64;
-    shaderRoundingModeRTEFloat16 = rhs.shaderRoundingModeRTEFloat16;
-    shaderRoundingModeRTEFloat32 = rhs.shaderRoundingModeRTEFloat32;
-    shaderRoundingModeRTEFloat64 = rhs.shaderRoundingModeRTEFloat64;
-    shaderRoundingModeRTZFloat16 = rhs.shaderRoundingModeRTZFloat16;
-    shaderRoundingModeRTZFloat32 = rhs.shaderRoundingModeRTZFloat32;
-    shaderRoundingModeRTZFloat64 = rhs.shaderRoundingModeRTZFloat64;
-    maxUpdateAfterBindDescriptorsInAllPools = rhs.maxUpdateAfterBindDescriptorsInAllPools;
-    shaderUniformBufferArrayNonUniformIndexingNative = rhs.shaderUniformBufferArrayNonUniformIndexingNative;
-    shaderSampledImageArrayNonUniformIndexingNative = rhs.shaderSampledImageArrayNonUniformIndexingNative;
-    shaderStorageBufferArrayNonUniformIndexingNative = rhs.shaderStorageBufferArrayNonUniformIndexingNative;
-    shaderStorageImageArrayNonUniformIndexingNative = rhs.shaderStorageImageArrayNonUniformIndexingNative;
-    shaderInputAttachmentArrayNonUniformIndexingNative = rhs.shaderInputAttachmentArrayNonUniformIndexingNative;
-    robustBufferAccessUpdateAfterBind = rhs.robustBufferAccessUpdateAfterBind;
-    quadDivergentImplicitLod = rhs.quadDivergentImplicitLod;
-    maxPerStageDescriptorUpdateAfterBindSamplers = rhs.maxPerStageDescriptorUpdateAfterBindSamplers;
-    maxPerStageDescriptorUpdateAfterBindUniformBuffers = rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
-    maxPerStageDescriptorUpdateAfterBindStorageBuffers = rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
-    maxPerStageDescriptorUpdateAfterBindSampledImages = rhs.maxPerStageDescriptorUpdateAfterBindSampledImages;
-    maxPerStageDescriptorUpdateAfterBindStorageImages = rhs.maxPerStageDescriptorUpdateAfterBindStorageImages;
-    maxPerStageDescriptorUpdateAfterBindInputAttachments = rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments;
-    maxPerStageUpdateAfterBindResources = rhs.maxPerStageUpdateAfterBindResources;
-    maxDescriptorSetUpdateAfterBindSamplers = rhs.maxDescriptorSetUpdateAfterBindSamplers;
-    maxDescriptorSetUpdateAfterBindUniformBuffers = rhs.maxDescriptorSetUpdateAfterBindUniformBuffers;
-    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
-    maxDescriptorSetUpdateAfterBindStorageBuffers = rhs.maxDescriptorSetUpdateAfterBindStorageBuffers;
-    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
-    maxDescriptorSetUpdateAfterBindSampledImages = rhs.maxDescriptorSetUpdateAfterBindSampledImages;
-    maxDescriptorSetUpdateAfterBindStorageImages = rhs.maxDescriptorSetUpdateAfterBindStorageImages;
-    maxDescriptorSetUpdateAfterBindInputAttachments = rhs.maxDescriptorSetUpdateAfterBindInputAttachments;
-    supportedDepthResolveModes = rhs.supportedDepthResolveModes;
-    supportedStencilResolveModes = rhs.supportedStencilResolveModes;
-    independentResolveNone = rhs.independentResolveNone;
-    independentResolve = rhs.independentResolve;
-    filterMinmaxSingleComponentFormats = rhs.filterMinmaxSingleComponentFormats;
-    filterMinmaxImageComponentMapping = rhs.filterMinmaxImageComponentMapping;
-    maxTimelineSemaphoreValueDifference = rhs.maxTimelineSemaphoreValueDifference;
-    framebufferIntegerColorSampleCounts = rhs.framebufferIntegerColorSampleCounts;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceVulkan12Properties ) );
       return *this;
     }
 
@@ -70248,6 +70041,8 @@
     : vulkanMemoryModel( vulkanMemoryModel_ ), vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ ), vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceVulkanMemoryModelFeatures( VkPhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70262,11 +70057,7 @@
 
     PhysicalDeviceVulkanMemoryModelFeatures & operator=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    vulkanMemoryModel = rhs.vulkanMemoryModel;
-    vulkanMemoryModelDeviceScope = rhs.vulkanMemoryModelDeviceScope;
-    vulkanMemoryModelAvailabilityVisibilityChains = rhs.vulkanMemoryModelAvailabilityVisibilityChains;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceVulkanMemoryModelFeatures ) );
       return *this;
     }
 
@@ -70354,6 +70145,8 @@
     : ycbcrImageArrays( ycbcrImageArrays_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70368,9 +70161,7 @@
 
     PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    ycbcrImageArrays = rhs.ycbcrImageArrays;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) );
       return *this;
     }
 
@@ -70441,6 +70232,8 @@
     : srcPremultiplied( srcPremultiplied_ ), dstPremultiplied( dstPremultiplied_ ), blendOverlap( blendOverlap_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70455,11 +70248,7 @@
 
     PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    srcPremultiplied = rhs.srcPremultiplied;
-    dstPremultiplied = rhs.dstPremultiplied;
-    blendOverlap = rhs.blendOverlap;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
       return *this;
     }
 
@@ -70546,6 +70335,8 @@
     : compilerControlFlags( compilerControlFlags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70560,9 +70351,7 @@
 
     PipelineCompilerControlCreateInfoAMD & operator=( PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    compilerControlFlags = rhs.compilerControlFlags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineCompilerControlCreateInfoAMD ) );
       return *this;
     }
 
@@ -70633,6 +70422,8 @@
     : flags( flags_ ), coverageModulationMode( coverageModulationMode_ ), coverageModulationTableEnable( coverageModulationTableEnable_ ), coverageModulationTableCount( coverageModulationTableCount_ ), pCoverageModulationTable( pCoverageModulationTable_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70653,13 +70444,7 @@
 
     PipelineCoverageModulationStateCreateInfoNV & operator=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    coverageModulationMode = rhs.coverageModulationMode;
-    coverageModulationTableEnable = rhs.coverageModulationTableEnable;
-    coverageModulationTableCount = rhs.coverageModulationTableCount;
-    pCoverageModulationTable = rhs.pCoverageModulationTable;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
       return *this;
     }
 
@@ -70771,6 +70556,8 @@
     : flags( flags_ ), coverageReductionMode( coverageReductionMode_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70785,10 +70572,7 @@
 
     PipelineCoverageReductionStateCreateInfoNV & operator=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    coverageReductionMode = rhs.coverageReductionMode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineCoverageReductionStateCreateInfoNV ) );
       return *this;
     }
 
@@ -70867,6 +70651,8 @@
     : flags( flags_ ), coverageToColorEnable( coverageToColorEnable_ ), coverageToColorLocation( coverageToColorLocation_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70881,11 +70667,7 @@
 
     PipelineCoverageToColorStateCreateInfoNV & operator=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    coverageToColorEnable = rhs.coverageToColorEnable;
-    coverageToColorLocation = rhs.coverageToColorLocation;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
       return *this;
     }
 
@@ -70971,6 +70753,8 @@
     : flags( flags_ ), duration( duration_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackEXT( PipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineCreationFeedbackEXT( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -70983,6 +70767,12 @@
       return *this;
     }
 
+    PipelineCreationFeedbackEXT & operator=( PipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineCreationFeedbackEXT ) );
+      return *this;
+    }
+
 
     operator VkPipelineCreationFeedbackEXT const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -71030,6 +70820,8 @@
     : pPipelineCreationFeedback( pPipelineCreationFeedback_ ), pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ ), pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( PipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71050,11 +70842,7 @@
 
     PipelineCreationFeedbackCreateInfoEXT & operator=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    pPipelineCreationFeedback = rhs.pPipelineCreationFeedback;
-    pipelineStageCreationFeedbackCount = rhs.pipelineStageCreationFeedbackCount;
-    pPipelineStageCreationFeedbacks = rhs.pPipelineStageCreationFeedbacks;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineCreationFeedbackCreateInfoEXT ) );
       return *this;
     }
 
@@ -71150,6 +70938,8 @@
     : flags( flags_ ), discardRectangleMode( discardRectangleMode_ ), discardRectangleCount( discardRectangleCount_ ), pDiscardRectangles( pDiscardRectangles_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71170,12 +70960,7 @@
 
     PipelineDiscardRectangleStateCreateInfoEXT & operator=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    discardRectangleMode = rhs.discardRectangleMode;
-    discardRectangleCount = rhs.discardRectangleCount;
-    pDiscardRectangles = rhs.pDiscardRectangles;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
       return *this;
     }
 
@@ -71279,6 +71064,8 @@
     : flags( flags_ ), conservativeRasterizationMode( conservativeRasterizationMode_ ), extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71293,11 +71080,7 @@
 
     PipelineRasterizationConservativeStateCreateInfoEXT & operator=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    conservativeRasterizationMode = rhs.conservativeRasterizationMode;
-    extraPrimitiveOverestimationSize = rhs.extraPrimitiveOverestimationSize;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
       return *this;
     }
 
@@ -71384,6 +71167,8 @@
     : flags( flags_ ), depthClipEnable( depthClipEnable_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71398,10 +71183,7 @@
 
     PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    depthClipEnable = rhs.depthClipEnable;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) );
       return *this;
     }
 
@@ -71480,6 +71262,8 @@
     : lineRasterizationMode( lineRasterizationMode_ ), stippledLineEnable( stippledLineEnable_ ), lineStippleFactor( lineStippleFactor_ ), lineStipplePattern( lineStipplePattern_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71494,12 +71278,7 @@
 
     PipelineRasterizationLineStateCreateInfoEXT & operator=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    lineRasterizationMode = rhs.lineRasterizationMode;
-    stippledLineEnable = rhs.stippledLineEnable;
-    lineStippleFactor = rhs.lineStippleFactor;
-    lineStipplePattern = rhs.lineStipplePattern;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineRasterizationLineStateCreateInfoEXT ) );
       return *this;
     }
 
@@ -71594,6 +71373,8 @@
     : rasterizationOrder( rasterizationOrder_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71608,9 +71389,7 @@
 
     PipelineRasterizationStateRasterizationOrderAMD & operator=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    rasterizationOrder = rhs.rasterizationOrder;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
       return *this;
     }
 
@@ -71681,6 +71460,8 @@
     : flags( flags_ ), rasterizationStream( rasterizationStream_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71695,10 +71476,7 @@
 
     PipelineRasterizationStateStreamCreateInfoEXT & operator=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    rasterizationStream = rhs.rasterizationStream;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
       return *this;
     }
 
@@ -71777,6 +71555,8 @@
     : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71791,9 +71571,7 @@
 
     PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    representativeFragmentTestEnable = rhs.representativeFragmentTestEnable;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
       return *this;
     }
 
@@ -71864,6 +71642,8 @@
     : sampleLocationsEnable( sampleLocationsEnable_ ), sampleLocationsInfo( sampleLocationsInfo_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71878,10 +71658,7 @@
 
     PipelineSampleLocationsStateCreateInfoEXT & operator=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    sampleLocationsEnable = rhs.sampleLocationsEnable;
-    sampleLocationsInfo = rhs.sampleLocationsInfo;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
       return *this;
     }
 
@@ -71960,6 +71737,8 @@
     : requiredSubgroupSize( requiredSubgroupSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -71974,9 +71753,7 @@
 
     PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT & operator=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    requiredSubgroupSize = rhs.requiredSubgroupSize;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) );
       return *this;
     }
 
@@ -72035,6 +71812,8 @@
     : domainOrigin( domainOrigin_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72049,9 +71828,7 @@
 
     PipelineTessellationDomainOriginStateCreateInfo & operator=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    domainOrigin = rhs.domainOrigin;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
       return *this;
     }
 
@@ -72122,6 +71899,8 @@
     : binding( binding_ ), divisor( divisor_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescriptionEXT( VertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72134,6 +71913,12 @@
       return *this;
     }
 
+    VertexInputBindingDivisorDescriptionEXT & operator=( VertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
+      return *this;
+    }
+
     VertexInputBindingDivisorDescriptionEXT & setBinding( uint32_t binding_ ) VULKAN_HPP_NOEXCEPT
     {
       binding = binding_;
@@ -72193,6 +71978,8 @@
     : vertexBindingDivisorCount( vertexBindingDivisorCount_ ), pVertexBindingDivisors( pVertexBindingDivisors_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72213,10 +72000,7 @@
 
     PipelineVertexInputDivisorStateCreateInfoEXT & operator=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    vertexBindingDivisorCount = rhs.vertexBindingDivisorCount;
-    pVertexBindingDivisors = rhs.pVertexBindingDivisors;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) );
       return *this;
     }
 
@@ -72304,6 +72088,8 @@
     : sampleOrderType( sampleOrderType_ ), customSampleOrderCount( customSampleOrderCount_ ), pCustomSampleOrders( pCustomSampleOrders_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72324,11 +72110,7 @@
 
     PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    sampleOrderType = rhs.sampleOrderType;
-    customSampleOrderCount = rhs.customSampleOrderCount;
-    pCustomSampleOrders = rhs.pCustomSampleOrders;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
       return *this;
     }
 
@@ -72424,6 +72206,8 @@
     : exclusiveScissorCount( exclusiveScissorCount_ ), pExclusiveScissors( pExclusiveScissors_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72444,10 +72228,7 @@
 
     PipelineViewportExclusiveScissorStateCreateInfoNV & operator=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    exclusiveScissorCount = rhs.exclusiveScissorCount;
-    pExclusiveScissors = rhs.pExclusiveScissors;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
       return *this;
     }
 
@@ -72535,6 +72316,8 @@
     : shadingRateImageEnable( shadingRateImageEnable_ ), viewportCount( viewportCount_ ), pShadingRatePalettes( pShadingRatePalettes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72555,11 +72338,7 @@
 
     PipelineViewportShadingRateImageStateCreateInfoNV & operator=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    shadingRateImageEnable = rhs.shadingRateImageEnable;
-    viewportCount = rhs.viewportCount;
-    pShadingRatePalettes = rhs.pShadingRatePalettes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
       return *this;
     }
 
@@ -72654,6 +72433,8 @@
     : x( x_ ), y( y_ ), z( z_ ), w( w_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( ViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72666,6 +72447,12 @@
       return *this;
     }
 
+    ViewportSwizzleNV & operator=( ViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ViewportSwizzleNV ) );
+      return *this;
+    }
+
     ViewportSwizzleNV & setX( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV x_ ) VULKAN_HPP_NOEXCEPT
     {
       x = x_;
@@ -72741,6 +72528,8 @@
     : flags( flags_ ), viewportCount( viewportCount_ ), pViewportSwizzles( pViewportSwizzles_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72761,11 +72550,7 @@
 
     PipelineViewportSwizzleStateCreateInfoNV & operator=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    viewportCount = rhs.viewportCount;
-    pViewportSwizzles = rhs.pViewportSwizzles;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
       return *this;
     }
 
@@ -72861,6 +72646,8 @@
     : viewportWScalingEnable( viewportWScalingEnable_ ), viewportCount( viewportCount_ ), pViewportWScalings( pViewportWScalings_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72881,11 +72668,7 @@
 
     PipelineViewportWScalingStateCreateInfoNV & operator=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    viewportWScalingEnable = rhs.viewportWScalingEnable;
-    viewportCount = rhs.viewportCount;
-    pViewportWScalings = rhs.pViewportWScalings;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
       return *this;
     }
 
@@ -72982,6 +72765,8 @@
     : frameToken( frameToken_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -72996,9 +72781,7 @@
 
     PresentFrameTokenGGP & operator=( PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    frameToken = rhs.frameToken;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PresentFrameTokenGGP ) );
       return *this;
     }
 
@@ -73069,6 +72852,8 @@
     : offset( offset_ ), extent( extent_ ), layer( layer_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RectLayerKHR( RectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RectLayerKHR( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73087,6 +72872,12 @@
       return *this;
     }
 
+    RectLayerKHR & operator=( RectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RectLayerKHR ) );
+      return *this;
+    }
+
     RectLayerKHR & setOffset( VULKAN_HPP_NAMESPACE::Offset2D const & offset_ ) VULKAN_HPP_NOEXCEPT
     {
       offset = offset_;
@@ -73153,6 +72944,8 @@
     : rectangleCount( rectangleCount_ ), pRectangles( pRectangles_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PresentRegionKHR( PresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PresentRegionKHR( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73171,6 +72964,12 @@
       return *this;
     }
 
+    PresentRegionKHR & operator=( PresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PresentRegionKHR ) );
+      return *this;
+    }
+
     PresentRegionKHR & setRectangleCount( uint32_t rectangleCount_ ) VULKAN_HPP_NOEXCEPT
     {
       rectangleCount = rectangleCount_;
@@ -73239,6 +73038,8 @@
     : swapchainCount( swapchainCount_ ), pRegions( pRegions_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PresentRegionsKHR( PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73259,10 +73060,7 @@
 
     PresentRegionsKHR & operator=( PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    swapchainCount = rhs.swapchainCount;
-    pRegions = rhs.pRegions;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PresentRegionsKHR ) );
       return *this;
     }
 
@@ -73349,6 +73147,8 @@
     : presentID( presentID_ ), desiredPresentTime( desiredPresentTime_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( PresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73361,6 +73161,12 @@
       return *this;
     }
 
+    PresentTimeGOOGLE & operator=( PresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PresentTimeGOOGLE ) );
+      return *this;
+    }
+
     PresentTimeGOOGLE & setPresentID( uint32_t presentID_ ) VULKAN_HPP_NOEXCEPT
     {
       presentID = presentID_;
@@ -73420,6 +73226,8 @@
     : swapchainCount( swapchainCount_ ), pTimes( pTimes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73440,10 +73248,7 @@
 
     PresentTimesInfoGOOGLE & operator=( PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    swapchainCount = rhs.swapchainCount;
-    pTimes = rhs.pTimes;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PresentTimesInfoGOOGLE ) );
       return *this;
     }
 
@@ -73531,6 +73336,8 @@
     : protectedSubmit( protectedSubmit_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73545,9 +73352,7 @@
 
     ProtectedSubmitInfo & operator=( ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    protectedSubmit = rhs.protectedSubmit;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ProtectedSubmitInfo ) );
       return *this;
     }
 
@@ -73618,6 +73423,8 @@
     : performanceCountersSampling( performanceCountersSampling_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR QueryPoolPerformanceQueryCreateInfoINTEL( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     QueryPoolPerformanceQueryCreateInfoINTEL( VkQueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73632,9 +73439,7 @@
 
     QueryPoolPerformanceQueryCreateInfoINTEL & operator=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    performanceCountersSampling = rhs.performanceCountersSampling;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( QueryPoolPerformanceQueryCreateInfoINTEL ) );
       return *this;
     }
 
@@ -73706,6 +73511,8 @@
     : checkpointExecutionStageMask( checkpointExecutionStageMask_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73720,9 +73527,7 @@
 
     QueueFamilyCheckpointPropertiesNV & operator=( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    checkpointExecutionStageMask = rhs.checkpointExecutionStageMask;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( QueueFamilyCheckpointPropertiesNV ) );
       return *this;
     }
 
@@ -73781,6 +73586,8 @@
     : attachmentCount( attachmentCount_ ), pAttachments( pAttachments_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfo( RenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassAttachmentBeginInfo( VkRenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73801,10 +73608,7 @@
 
     RenderPassAttachmentBeginInfo & operator=( RenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    attachmentCount = rhs.attachmentCount;
-    pAttachments = rhs.pAttachments;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassAttachmentBeginInfo ) );
       return *this;
     }
 
@@ -73893,6 +73697,8 @@
     : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -73907,9 +73713,7 @@
 
     RenderPassFragmentDensityMapCreateInfoEXT & operator=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fragmentDensityMapAttachment = rhs.fragmentDensityMapAttachment;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) );
       return *this;
     }
 
@@ -73980,6 +73784,8 @@
     : aspectReferenceCount( aspectReferenceCount_ ), pAspectReferences( pAspectReferences_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74000,10 +73806,7 @@
 
     RenderPassInputAttachmentAspectCreateInfo & operator=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    aspectReferenceCount = rhs.aspectReferenceCount;
-    pAspectReferences = rhs.pAspectReferences;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
       return *this;
     }
 
@@ -74092,6 +73895,8 @@
     : subpassCount( subpassCount_ ), pViewMasks( pViewMasks_ ), dependencyCount( dependencyCount_ ), pViewOffsets( pViewOffsets_ ), correlationMaskCount( correlationMaskCount_ ), pCorrelationMasks( pCorrelationMasks_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74112,14 +73917,7 @@
 
     RenderPassMultiviewCreateInfo & operator=( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    subpassCount = rhs.subpassCount;
-    pViewMasks = rhs.pViewMasks;
-    dependencyCount = rhs.dependencyCount;
-    pViewOffsets = rhs.pViewOffsets;
-    correlationMaskCount = rhs.correlationMaskCount;
-    pCorrelationMasks = rhs.pCorrelationMasks;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
       return *this;
     }
 
@@ -74257,6 +74055,8 @@
     : subpassIndex( subpassIndex_ ), sampleLocationsInfo( sampleLocationsInfo_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( SubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74269,6 +74069,12 @@
       return *this;
     }
 
+    SubpassSampleLocationsEXT & operator=( SubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubpassSampleLocationsEXT ) );
+      return *this;
+    }
+
     SubpassSampleLocationsEXT & setSubpassIndex( uint32_t subpassIndex_ ) VULKAN_HPP_NOEXCEPT
     {
       subpassIndex = subpassIndex_;
@@ -74328,6 +74134,8 @@
     : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ), pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ), postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ), pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74348,12 +74156,7 @@
 
     RenderPassSampleLocationsBeginInfoEXT & operator=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    attachmentInitialSampleLocationsCount = rhs.attachmentInitialSampleLocationsCount;
-    pAttachmentInitialSampleLocations = rhs.pAttachmentInitialSampleLocations;
-    postSubpassSampleLocationsCount = rhs.postSubpassSampleLocationsCount;
-    pPostSubpassSampleLocations = rhs.pPostSubpassSampleLocations;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
       return *this;
     }
 
@@ -74466,6 +74269,8 @@
     : transform( transform_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( RenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     RenderPassTransformBeginInfoQCOM( VkRenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74480,9 +74285,7 @@
 
     RenderPassTransformBeginInfoQCOM & operator=( RenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    transform = rhs.transform;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( RenderPassTransformBeginInfoQCOM ) );
       return *this;
     }
 
@@ -74553,6 +74356,8 @@
     : customBorderColor( customBorderColor_ ), format( format_ )
     {}
 
+    SamplerCustomBorderColorCreateInfoEXT( SamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SamplerCustomBorderColorCreateInfoEXT( VkSamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74567,10 +74372,7 @@
 
     SamplerCustomBorderColorCreateInfoEXT & operator=( SamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    customBorderColor = rhs.customBorderColor;
-    format = rhs.format;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SamplerCustomBorderColorCreateInfoEXT ) );
       return *this;
     }
 
@@ -74632,6 +74434,8 @@
     : reductionMode( reductionMode_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( SamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SamplerReductionModeCreateInfo( VkSamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74646,9 +74450,7 @@
 
     SamplerReductionModeCreateInfo & operator=( SamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    reductionMode = rhs.reductionMode;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SamplerReductionModeCreateInfo ) );
       return *this;
     }
 
@@ -74720,6 +74522,8 @@
     : combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74734,9 +74538,7 @@
 
     SamplerYcbcrConversionImageFormatProperties & operator=( SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    combinedImageSamplerDescriptorCount = rhs.combinedImageSamplerDescriptorCount;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SamplerYcbcrConversionImageFormatProperties ) );
       return *this;
     }
 
@@ -74796,6 +74598,8 @@
     : conversion( conversion_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74810,9 +74614,7 @@
 
     SamplerYcbcrConversionInfo & operator=( SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    conversion = rhs.conversion;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SamplerYcbcrConversionInfo ) );
       return *this;
     }
 
@@ -74884,6 +74686,8 @@
     : semaphoreType( semaphoreType_ ), initialValue( initialValue_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( SemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SemaphoreTypeCreateInfo( VkSemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74898,10 +74702,7 @@
 
     SemaphoreTypeCreateInfo & operator=( SemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    semaphoreType = rhs.semaphoreType;
-    initialValue = rhs.initialValue;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SemaphoreTypeCreateInfo ) );
       return *this;
     }
 
@@ -74980,6 +74781,8 @@
     : data( data_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( SetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SetStateFlagsIndirectCommandNV( VkSetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -74992,6 +74795,12 @@
       return *this;
     }
 
+    SetStateFlagsIndirectCommandNV & operator=( SetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SetStateFlagsIndirectCommandNV ) );
+      return *this;
+    }
+
     SetStateFlagsIndirectCommandNV & setData( uint32_t data_ ) VULKAN_HPP_NOEXCEPT
     {
       data = data_;
@@ -75043,6 +74852,8 @@
     : validationCache( validationCache_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75057,9 +74868,7 @@
 
     ShaderModuleValidationCacheCreateInfoEXT & operator=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    validationCache = rhs.validationCache;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
       return *this;
     }
 
@@ -75129,6 +74938,8 @@
     : numUsedVgprs( numUsedVgprs_ ), numUsedSgprs( numUsedSgprs_ ), ldsSizePerLocalWorkGroup( ldsSizePerLocalWorkGroup_ ), ldsUsageSizeInBytes( ldsUsageSizeInBytes_ ), scratchMemUsageInBytes( scratchMemUsageInBytes_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( ShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75141,6 +74952,12 @@
       return *this;
     }
 
+    ShaderResourceUsageAMD & operator=( ShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ShaderResourceUsageAMD ) );
+      return *this;
+    }
+
 
     operator VkShaderResourceUsageAMD const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -75193,6 +75010,8 @@
     : shaderStageMask( shaderStageMask_ ), resourceUsage( resourceUsage_ ), numPhysicalVgprs( numPhysicalVgprs_ ), numPhysicalSgprs( numPhysicalSgprs_ ), numAvailableVgprs( numAvailableVgprs_ ), numAvailableSgprs( numAvailableSgprs_ ), computeWorkGroupSize( computeWorkGroupSize_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR_14 ShaderStatisticsInfoAMD( ShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75205,6 +75024,12 @@
       return *this;
     }
 
+    ShaderStatisticsInfoAMD & operator=( ShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ShaderStatisticsInfoAMD ) );
+      return *this;
+    }
+
 
     operator VkShaderStatisticsInfoAMD const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -75262,6 +75087,8 @@
     : sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75276,9 +75103,7 @@
 
     SharedPresentSurfaceCapabilitiesKHR & operator=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    sharedPresentSupportedUsageFlags = rhs.sharedPresentSupportedUsageFlags;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SharedPresentSurfaceCapabilitiesKHR ) );
       return *this;
     }
 
@@ -75338,6 +75163,8 @@
     : flags( flags_ ), streamDescriptor( streamDescriptor_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75352,10 +75179,7 @@
 
     StreamDescriptorSurfaceCreateInfoGGP & operator=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    streamDescriptor = rhs.streamDescriptor;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( StreamDescriptorSurfaceCreateInfoGGP ) );
       return *this;
     }
 
@@ -75435,6 +75259,8 @@
     : depthResolveMode( depthResolveMode_ ), stencilResolveMode( stencilResolveMode_ ), pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( SubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SubpassDescriptionDepthStencilResolve( VkSubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75449,11 +75275,7 @@
 
     SubpassDescriptionDepthStencilResolve & operator=( SubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    depthResolveMode = rhs.depthResolveMode;
-    stencilResolveMode = rhs.stencilResolveMode;
-    pDepthStencilResolveAttachment = rhs.pDepthStencilResolveAttachment;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SubpassDescriptionDepthStencilResolve ) );
       return *this;
     }
 
@@ -75542,6 +75364,8 @@
     : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75556,9 +75380,7 @@
 
     SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fullScreenExclusiveSupported = rhs.fullScreenExclusiveSupported;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) );
       return *this;
     }
 
@@ -75631,6 +75453,8 @@
     : fullScreenExclusive( fullScreenExclusive_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75645,9 +75469,7 @@
 
     SurfaceFullScreenExclusiveInfoEXT & operator=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    fullScreenExclusive = rhs.fullScreenExclusive;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceFullScreenExclusiveInfoEXT ) );
       return *this;
     }
 
@@ -75720,6 +75542,8 @@
     : hmonitor( hmonitor_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75734,9 +75558,7 @@
 
     SurfaceFullScreenExclusiveWin32InfoEXT & operator=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    hmonitor = rhs.hmonitor;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) );
       return *this;
     }
 
@@ -75808,6 +75630,8 @@
     : supportsProtected( supportsProtected_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75822,9 +75646,7 @@
 
     SurfaceProtectedCapabilitiesKHR & operator=( SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    supportsProtected = rhs.supportsProtected;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SurfaceProtectedCapabilitiesKHR ) );
       return *this;
     }
 
@@ -75895,6 +75717,8 @@
     : surfaceCounters( surfaceCounters_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75909,9 +75733,7 @@
 
     SwapchainCounterCreateInfoEXT & operator=( SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    surfaceCounters = rhs.surfaceCounters;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
       return *this;
     }
 
@@ -75982,6 +75804,8 @@
     : localDimmingEnable( localDimmingEnable_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -75996,9 +75820,7 @@
 
     SwapchainDisplayNativeHdrCreateInfoAMD & operator=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    localDimmingEnable = rhs.localDimmingEnable;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) );
       return *this;
     }
 
@@ -76069,6 +75891,8 @@
     : supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -76083,9 +75907,7 @@
 
     TextureLODGatherFormatPropertiesAMD & operator=( TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    supportsTextureGatherLODBiasAMD = rhs.supportsTextureGatherLODBiasAMD;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( TextureLODGatherFormatPropertiesAMD ) );
       return *this;
     }
 
@@ -76144,6 +75966,8 @@
     : waitSemaphoreValueCount( waitSemaphoreValueCount_ ), pWaitSemaphoreValues( pWaitSemaphoreValues_ ), signalSemaphoreValueCount( signalSemaphoreValueCount_ ), pSignalSemaphoreValues( pSignalSemaphoreValues_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( TimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     TimelineSemaphoreSubmitInfo( VkTimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -76164,12 +75988,7 @@
 
     TimelineSemaphoreSubmitInfo & operator=( TimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    waitSemaphoreValueCount = rhs.waitSemaphoreValueCount;
-    pWaitSemaphoreValues = rhs.pWaitSemaphoreValues;
-    signalSemaphoreValueCount = rhs.signalSemaphoreValueCount;
-    pSignalSemaphoreValues = rhs.pSignalSemaphoreValues;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( TimelineSemaphoreSubmitInfo ) );
       return *this;
     }
 
@@ -76283,6 +76102,8 @@
     : width( width_ ), height( height_ ), depth( depth_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommandKHR( TraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     TraceRaysIndirectCommandKHR( VkTraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -76301,6 +76122,12 @@
       return *this;
     }
 
+    TraceRaysIndirectCommandKHR & operator=( TraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( TraceRaysIndirectCommandKHR ) );
+      return *this;
+    }
+
     TraceRaysIndirectCommandKHR & setWidth( uint32_t width_ ) VULKAN_HPP_NOEXCEPT
     {
       width = width_;
@@ -76369,6 +76196,8 @@
     : enabledValidationFeatureCount( enabledValidationFeatureCount_ ), pEnabledValidationFeatures( pEnabledValidationFeatures_ ), disabledValidationFeatureCount( disabledValidationFeatureCount_ ), pDisabledValidationFeatures( pDisabledValidationFeatures_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -76389,12 +76218,7 @@
 
     ValidationFeaturesEXT & operator=( ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    enabledValidationFeatureCount = rhs.enabledValidationFeatureCount;
-    pEnabledValidationFeatures = rhs.pEnabledValidationFeatures;
-    disabledValidationFeatureCount = rhs.disabledValidationFeatureCount;
-    pDisabledValidationFeatures = rhs.pDisabledValidationFeatures;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ValidationFeaturesEXT ) );
       return *this;
     }
 
@@ -76507,6 +76331,8 @@
     : disabledValidationCheckCount( disabledValidationCheckCount_ ), pDisabledValidationChecks( pDisabledValidationChecks_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -76527,10 +76353,7 @@
 
     ValidationFlagsEXT & operator=( ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    disabledValidationCheckCount = rhs.disabledValidationCheckCount;
-    pDisabledValidationChecks = rhs.pDisabledValidationChecks;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ValidationFlagsEXT ) );
       return *this;
     }
 
@@ -76619,6 +76442,8 @@
     : flags( flags_ ), window( window_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -76633,10 +76458,7 @@
 
     ViSurfaceCreateInfoNN & operator=( ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    window = rhs.window;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( ViSurfaceCreateInfoNN ) );
       return *this;
     }
 
@@ -76717,6 +76539,8 @@
     : flags( flags_ ), display( display_ ), surface( surface_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -76731,11 +76555,7 @@
 
     WaylandSurfaceCreateInfoKHR & operator=( WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    display = rhs.display;
-    surface = rhs.surface;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
       return *this;
     }
 
@@ -76824,6 +76644,8 @@
     : acquireCount( acquireCount_ ), pAcquireSyncs( pAcquireSyncs_ ), pAcquireKeys( pAcquireKeys_ ), pAcquireTimeouts( pAcquireTimeouts_ ), releaseCount( releaseCount_ ), pReleaseSyncs( pReleaseSyncs_ ), pReleaseKeys( pReleaseKeys_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -76872,15 +76694,7 @@
 
     Win32KeyedMutexAcquireReleaseInfoKHR & operator=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    acquireCount = rhs.acquireCount;
-    pAcquireSyncs = rhs.pAcquireSyncs;
-    pAcquireKeys = rhs.pAcquireKeys;
-    pAcquireTimeouts = rhs.pAcquireTimeouts;
-    releaseCount = rhs.releaseCount;
-    pReleaseSyncs = rhs.pReleaseSyncs;
-    pReleaseKeys = rhs.pReleaseKeys;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
       return *this;
     }
 
@@ -77046,6 +76860,8 @@
     : acquireCount( acquireCount_ ), pAcquireSyncs( pAcquireSyncs_ ), pAcquireKeys( pAcquireKeys_ ), pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ), releaseCount( releaseCount_ ), pReleaseSyncs( pReleaseSyncs_ ), pReleaseKeys( pReleaseKeys_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -77094,15 +76910,7 @@
 
     Win32KeyedMutexAcquireReleaseInfoNV & operator=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    acquireCount = rhs.acquireCount;
-    pAcquireSyncs = rhs.pAcquireSyncs;
-    pAcquireKeys = rhs.pAcquireKeys;
-    pAcquireTimeoutMilliseconds = rhs.pAcquireTimeoutMilliseconds;
-    releaseCount = rhs.releaseCount;
-    pReleaseSyncs = rhs.pReleaseSyncs;
-    pReleaseKeys = rhs.pReleaseKeys;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
       return *this;
     }
 
@@ -77268,6 +77076,8 @@
     : flags( flags_ ), hinstance( hinstance_ ), hwnd( hwnd_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -77282,11 +77092,7 @@
 
     Win32SurfaceCreateInfoKHR & operator=( Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    hinstance = rhs.hinstance;
-    hwnd = rhs.hwnd;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
       return *this;
     }
 
@@ -77374,6 +77180,8 @@
     : accelerationStructureCount( accelerationStructureCount_ ), pAccelerationStructures( pAccelerationStructures_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( WriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     WriteDescriptorSetAccelerationStructureKHR( VkWriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -77394,10 +77202,7 @@
 
     WriteDescriptorSetAccelerationStructureKHR & operator=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    accelerationStructureCount = rhs.accelerationStructureCount;
-    pAccelerationStructures = rhs.pAccelerationStructures;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( WriteDescriptorSetAccelerationStructureKHR ) );
       return *this;
     }
 
@@ -77486,6 +77291,8 @@
     : dataSize( dataSize_ ), pData( pData_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -77507,10 +77314,7 @@
 
     WriteDescriptorSetInlineUniformBlockEXT & operator=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    dataSize = rhs.dataSize;
-    pData = rhs.pData;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
       return *this;
     }
 
@@ -77600,6 +77404,8 @@
     : flags( flags_ ), connection( connection_ ), window( window_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -77614,11 +77420,7 @@
 
     XcbSurfaceCreateInfoKHR & operator=( XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    connection = rhs.connection;
-    window = rhs.window;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
       return *this;
     }
 
@@ -77707,6 +77509,8 @@
     : flags( flags_ ), dpy( dpy_ ), window( window_ )
     {}
 
+    VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
     XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
       *this = rhs;
@@ -77721,11 +77525,7 @@
 
     XlibSurfaceCreateInfoKHR & operator=( XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-    pNext = rhs.pNext;
-    flags = rhs.flags;
-    dpy = rhs.dpy;
-    window = rhs.window;
-
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
       return *this;
     }
 
@@ -82883,20 +82683,45 @@
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-  template<typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV(  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, size_t dataSize, void* pData, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), dataSize, pData ) );
+        return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), dataSize, pData ) );
+
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, ArrayProxy<T> const &data, Dispatch const &d ) const
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it.")
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getAccelerationStructureHandleNV(  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, ArrayProxy<T> const &data, Dispatch const &d  ) const
   {
-    Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+        Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" );
+
+  }
+
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T,Allocator>>::type Device::getAccelerationStructureHandleNV(  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, size_t dataSize, Dispatch const &d  ) const
+  {
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T,Allocator> data( dataSize / sizeof( T ) );
+        Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
+  }
+
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type Device::getAccelerationStructureHandleNV(  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, Dispatch const &d  ) const
+  {
+    T data;
+        Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureKHR>( accelerationStructure ), 1 * sizeof( T ) , reinterpret_cast<void*>( &data ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   template<typename Dispatch>
   VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoKHR* pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
@@ -84066,66 +83891,165 @@
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template<typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults(  VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
+        return static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
+
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> const &data, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d ) const
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it.")
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults(  VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> const &data, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d  ) const
   {
-    Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
+        Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
+
+  }
+
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<T,Allocator>> Device::getQueryPoolResults(  VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d  ) const
+  {
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T,Allocator> data( dataSize / sizeof( T ) );
+        Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
+  }
+
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<T> Device::getQueryPoolResult(  VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d  ) const
+  {
+    T data;
+        Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, 1 * sizeof( T ) , reinterpret_cast<void*>( &data ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
-  template<typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingCaptureReplayShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+        return static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d ) const
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it.")
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getRayTracingCaptureReplayShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d  ) const
   {
-    Result result = static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+        Result result = static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
+
+  }
+
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T,Allocator>>::type Device::getRayTracingCaptureReplayShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d  ) const
+  {
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T,Allocator> data( dataSize / sizeof( T ) );
+        Result result = static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
+  }
+
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type Device::getRayTracingCaptureReplayShaderGroupHandleKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d  ) const
+  {
+    T data;
+        Result result = static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, 1 * sizeof( T ) , reinterpret_cast<void*>( &data ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
+
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
-  template<typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+        return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d ) const
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it.")
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d  ) const
   {
-    Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+        Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesKHR" );
+
+  }
+
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T,Allocator>>::type Device::getRayTracingShaderGroupHandlesKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d  ) const
+  {
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T,Allocator> data( dataSize / sizeof( T ) );
+        Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
+  }
+
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type Device::getRayTracingShaderGroupHandleKHR(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d  ) const
+  {
+    T data;
+        Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, 1 * sizeof( T ) , reinterpret_cast<void*>( &data ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
-  template<typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT
   {
-    return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+        return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename T, typename Dispatch>
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d ) const
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it.")
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> const &data, Dispatch const &d  ) const
   {
-    Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+        Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
+
+  }
+
+  template <typename T, typename Allocator, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T,Allocator>>::type Device::getRayTracingShaderGroupHandlesNV(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d  ) const
+  {
+    VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 );
+    std::vector<T,Allocator> data( dataSize / sizeof( T ) );
+        Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
+  }
+
+  template <typename T, typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type Device::getRayTracingShaderGroupHandleNV(  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d  ) const
+  {
+    T data;
+        Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, 1 * sizeof( T ) , reinterpret_cast<void*>( &data ) ) );
+
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+
   template<typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
   {
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 14a417f..9dfdad0 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -43,7 +43,7 @@
 #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 152
+#define VK_HEADER_VERSION 153
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_VERSION(1, 2, VK_HEADER_VERSION)
diff --git a/registry/validusage.json b/registry/validusage.json
index f8d862c..0d914f8 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.152",
-    "comment": "from git branch: github-master commit: ef2bc9f8b9b6693634b9e3ac345ac5ca15233208",
-    "date": "2020-08-26 13:27:20Z"
+    "api version": "1.2.153",
+    "comment": "from git branch: github-main commit: 72254079510ec0616b711a570d83a6f1476ebc97",
+    "date": "2020-09-07 02:44:48Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -2025,6 +2025,10 @@
     "vkImportFenceWin32HandleKHR": {
       "(VK_KHR_external_fence_win32)": [
         {
+          "vuid": "VUID-vkImportFenceWin32HandleKHR-fence-04448",
+          "text": " <code>fence</code> <strong class=\"purple\">must</strong> not be associated with any queue command that has not yet completed execution on that queue"
+        },
+        {
           "vuid": "VUID-vkImportFenceWin32HandleKHR-device-parameter",
           "text": " <code>device</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDevice\">VkDevice</a> handle"
         },
@@ -27731,7 +27735,7 @@
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD</code>"
         },
         {
-          "vuid": "VUID-VkSwapchainDisplayNativeHdrCreateInfoAMD-localDimmingEnable-XXXXX",
+          "vuid": "VUID-VkSwapchainDisplayNativeHdrCreateInfoAMD-localDimmingEnable-04449",
           "text": " It is only valid to set <code>localDimmingEnable</code> to <code>VK_TRUE</code> if <a href=\"#VkDisplayNativeHdrSurfaceCapabilitiesAMD\">VkDisplayNativeHdrSurfaceCapabilitiesAMD</a>::<code>localDimmingSupport</code> is supported"
         }
       ]
diff --git a/registry/vk.xml b/registry/vk.xml
index a4df3e8..5d34bab 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -13,9 +13,9 @@
 language incorporated into the Specification and reference pages, and other
 material which is registered by Khronos, such as tags used by extension and
 layer authors. The authoritative public version of vk.xml is maintained in
-the master branch of the Khronos Vulkan GitHub project. The authoritative
-private version is maintained in the master branch of the member gitlab
-server.
+the default branch (currently named main) of the Khronos Vulkan GitHub
+project. The authoritative private version is maintained in the default
+branch of the member gitlab server.
     </comment>
 
     <platforms comment="Vulkan platform names, reserved for use with platform- and window system-specific extensions">
@@ -135,7 +135,7 @@
         <type category="define">// Vulkan 1.2 version number
 #define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_VERSION</type>(1, 2, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 152</type>
+#define <name>VK_HEADER_VERSION</name> 153</type>
         <type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_VERSION</type>(1, 2, VK_HEADER_VERSION)</type>
 
@@ -13915,6 +13915,7 @@
             <require>
                 <enum value="0"                                             name="VK_KHR_EXTENSION_350_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_extension_350&quot;"              name="VK_KHR_EXTENSION_350_EXTENSION_NAME"/>
+                <enum bitpos="2"  extends="VkPipelineCacheCreateFlagBits"   name="VK_PIPELINE_CACHE_CREATE_RESERVED_2_BIT_EXT"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_351" number="351" author="NV" contact="Liam Middlebrook @liam-middlebrook" supported="disabled">
@@ -13935,5 +13936,11 @@
                 <enum value="&quot;VK_EXT_extension_353&quot;"              name="VK_EXT_EXTENSION_353_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_EXT_extension_354" number="354" author="EXT" contact="Simon Ser @emersion" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_354_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_354&quot;"              name="VK_EXT_EXTENSION_354_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
 </registry>