diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index b7d954b..cbd0beb 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -3954,43 +3954,40 @@ void VulkanHppGenerator::writeStructConstructor(std::ostream & os, std::string c
   // the constructor with all the elements as arguments, with defaults
   os << "    " << name << "( ";
   bool listedArgument = false;
-  if (!structData.returnedOnly)
+  for (size_t i = 0; i < structData.members.size(); i++)
   {
-    for (size_t i = 0; i < structData.members.size(); i++)
+    if (listedArgument)
     {
-      if (listedArgument)
-      {
-        os << ", ";
-      }
-      // skip members 'pNext' and 'sType', as they are never explicitly set
-      if ((structData.members[i].name != "pNext") && (structData.members[i].name != "sType"))
-      {
-        // find a default value for the given pure type
-        std::map<std::string, std::string>::const_iterator defaultIt = defaultValues.find(structData.members[i].pureType);
-        assert(defaultIt != defaultValues.end());
+      os << ", ";
+    }
+    // skip members 'pNext' and 'sType', as they are never explicitly set
+    if ((structData.members[i].name != "pNext") && (structData.members[i].name != "sType"))
+    {
+      // find a default value for the given pure type
+      std::map<std::string, std::string>::const_iterator defaultIt = defaultValues.find(structData.members[i].pureType);
+      assert(defaultIt != defaultValues.end());
 
-        if (structData.members[i].arraySize.empty())
-        {
-          // the arguments name get a trailing '_', to distinguish them from the actual struct members
-          // pointer arguments get a nullptr as default
-          os << structData.members[i].type << " " << structData.members[i].name << "_ = " << (structData.members[i].type.back() == '*' ? "nullptr" : defaultIt->second);
-        }
-        else
-        {
-          // array members are provided as const reference to a std::array
-          // the arguments name get a trailing '_', to distinguish them from the actual struct members
-          // list as many default values as there are elements in the array
-          os << "std::array<" << structData.members[i].type << "," << structData.members[i].arraySize << "> const& " << structData.members[i].name << "_ = { { " << defaultIt->second;
-          size_t n = atoi(structData.members[i].arraySize.c_str());
-          assert(0 < n);
-          for (size_t j = 1; j < n; j++)
-          {
-            os << ", " << defaultIt->second;
-          }
-          os << " } }";
-        }
-        listedArgument = true;
+      if (structData.members[i].arraySize.empty())
+      {
+        // the arguments name get a trailing '_', to distinguish them from the actual struct members
+        // pointer arguments get a nullptr as default
+        os << structData.members[i].type << " " << structData.members[i].name << "_ = " << (structData.members[i].type.back() == '*' ? "nullptr" : defaultIt->second);
       }
+      else
+      {
+        // array members are provided as const reference to a std::array
+        // the arguments name get a trailing '_', to distinguish them from the actual struct members
+        // list as many default values as there are elements in the array
+        os << "std::array<" << structData.members[i].type << "," << structData.members[i].arraySize << "> const& " << structData.members[i].name << "_ = { { " << defaultIt->second;
+        size_t n = atoi(structData.members[i].arraySize.c_str());
+        assert(0 < n);
+        for (size_t j = 1; j < n; j++)
+        {
+          os << ", " << defaultIt->second;
+        }
+        os << " } }";
+      }
+      listedArgument = true;
     }
   }
   os << " )" << std::endl;
@@ -3999,38 +3996,15 @@ void VulkanHppGenerator::writeStructConstructor(std::ostream & os, std::string c
   bool firstArgument = true;
   for (size_t i = 0; i < structData.members.size(); i++)
   {
-    if (structData.members[i].arraySize.empty())
+    // skip members 'pNext' and 'sType' are directly set by initializers
+    if ((structData.members[i].name != "pNext") && (structData.members[i].name != "sType") && (structData.members[i].arraySize.empty()))
     {
       // here, we can only handle non-array arguments
       std::string templateString = "      ${sep} ${member}( ${value} )\n";
       std::string sep = firstArgument ? ":" : ",";
       std::string member = structData.members[i].name;
-      std::string value;
+      std::string value = structData.members[i].name + "_";   // the elements are initialized by the corresponding argument (with trailing '_', as mentioned above)
 
-      // 'pNext' and 'sType' don't get an argument, use nullptr and the correct StructureType enum value to initialize them
-      if (structData.members[i].name == "pNext")
-      {
-        value = "nullptr";
-      }
-      else if (structData.members[i].name == "sType")
-      {
-        assert(!structData.members[i].values.empty());
-        auto nameIt = m_nameMap.find(structData.members[i].values);
-        assert(nameIt != m_nameMap.end());
-        value = nameIt->second;
-      }
-      else
-      {
-        if (!structData.returnedOnly)
-        {
-          // the other elements are initialized by the corresponding argument (with trailing '_', as mentioned above)
-          value = structData.members[i].name + "_";
-        }
-        else
-        {
-          templateString = "";
-        }
-      }
       os << replaceWithMap(templateString, { { "sep", sep },{ "member", member },{ "value", value } });
       firstArgument = false;
     }
@@ -4038,20 +4012,17 @@ void VulkanHppGenerator::writeStructConstructor(std::ostream & os, std::string c
 
   // the body of the constructor, copying over data from argument list into wrapped struct
   os << "    {" << std::endl;
-  if (!structData.returnedOnly)
+  for (size_t i = 0; i < structData.members.size(); i++)
   {
-    for (size_t i = 0; i < structData.members.size(); i++)
+    if (!structData.members[i].arraySize.empty())
     {
-      if (!structData.members[i].arraySize.empty())
-      {
-        // here we can handle the arrays, copying over from argument (with trailing '_') to member
-        // size is arraySize times sizeof type
-        std::string member = structData.members[i].name;
-        std::string arraySize = structData.members[i].arraySize;
-        std::string type = structData.members[i].type;
-        os << replaceWithMap("      memcpy( &${member}, ${member}_.data(), ${arraySize} * sizeof( ${type} ) );\n",
-        { { "member", member },{ "arraySize", arraySize },{ "type", type } });
-      }
+      // here we can handle the arrays, copying over from argument (with trailing '_') to member
+      // size is arraySize times sizeof type
+      std::string member = structData.members[i].name;
+      std::string arraySize = structData.members[i].arraySize;
+      std::string type = structData.members[i].type;
+      os << replaceWithMap("      memcpy( &${member}, ${member}_.data(), ${arraySize} * sizeof( ${type} ) );\n",
+      { { "member", member },{ "arraySize", arraySize },{ "type", type } });
     }
   }
   os << "    }\n\n";
@@ -4536,7 +4507,11 @@ void VulkanHppGenerator::writeTypeStruct(std::ostream & os, DependencyData const
   os << "  struct " << dependencyData.name << std::endl
     << "  {" << std::endl;
 
-  writeStructConstructor(os, dependencyData.name, it->second, defaultValues);
+  // only structs that are not returnedOnly get a constructor!
+  if (!it->second.returnedOnly)
+  {
+    writeStructConstructor(os, dependencyData.name, it->second, defaultValues);
+  }
 
   // create the setters
   if (!it->second.returnedOnly)
@@ -4593,15 +4568,22 @@ void VulkanHppGenerator::writeTypeStruct(std::ostream & os, DependencyData const
     if (it->second.members[i].type == "StructureType")
     {
       assert((i == 0) && (it->second.members[i].name == "sType"));
+      assert(!it->second.members[i].values.empty());
+      auto nameIt = m_nameMap.find(it->second.members[i].values);
+      assert(nameIt != m_nameMap.end());
       os << "  private:" << std::endl
-        << "    StructureType sType;" << std::endl
+        << "    StructureType sType = " << nameIt->second << ";" << std::endl
         << std::endl
         << "  public:" << std::endl;
     }
     else
     {
       os << "    " << it->second.members[i].type << " " << it->second.members[i].name;
-      if (!it->second.members[i].arraySize.empty())
+      if (it->second.members[i].name == "pNext")
+      {
+        os << " = nullptr";
+      }
+      else if (!it->second.members[i].arraySize.empty())
       {
         os << "[" << it->second.members[i].arraySize << "]";
       }
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 24e2b60..9b5a048 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -3685,20 +3685,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExtensionProperties
   {
-    ExtensionProperties(  )
-    {
-    }
-
-    ExtensionProperties( VkExtensionProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExtensionProperties ) );
-    }
-
-    ExtensionProperties& operator=( VkExtensionProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExtensionProperties ) );
-      return *this;
-    }
     operator const VkExtensionProperties&() const
     {
       return *reinterpret_cast<const VkExtensionProperties*>(this);
@@ -3722,20 +3708,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct LayerProperties
   {
-    LayerProperties(  )
-    {
-    }
-
-    LayerProperties( VkLayerProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( LayerProperties ) );
-    }
-
-    LayerProperties& operator=( VkLayerProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( LayerProperties ) );
-      return *this;
-    }
     operator const VkLayerProperties&() const
     {
       return *reinterpret_cast<const VkLayerProperties*>(this);
@@ -3850,20 +3822,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct MemoryRequirements
   {
-    MemoryRequirements(  )
-    {
-    }
-
-    MemoryRequirements( VkMemoryRequirements const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryRequirements ) );
-    }
-
-    MemoryRequirements& operator=( VkMemoryRequirements const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryRequirements ) );
-      return *this;
-    }
     operator const VkMemoryRequirements&() const
     {
       return *reinterpret_cast<const VkMemoryRequirements*>(this);
@@ -3949,20 +3907,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SubresourceLayout
   {
-    SubresourceLayout(  )
-    {
-    }
-
-    SubresourceLayout( VkSubresourceLayout const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubresourceLayout ) );
-    }
-
-    SubresourceLayout& operator=( VkSubresourceLayout const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubresourceLayout ) );
-      return *this;
-    }
     operator const VkSubresourceLayout&() const
     {
       return *reinterpret_cast<const VkSubresourceLayout*>(this);
@@ -4843,20 +4787,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceSparseProperties
   {
-    PhysicalDeviceSparseProperties(  )
-    {
-    }
-
-    PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSparseProperties ) );
-    }
-
-    PhysicalDeviceSparseProperties& operator=( VkPhysicalDeviceSparseProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSparseProperties ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceSparseProperties&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this);
@@ -5093,20 +5023,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct DisplayPlanePropertiesKHR
   {
-    DisplayPlanePropertiesKHR(  )
-    {
-    }
-
-    DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPlanePropertiesKHR ) );
-    }
-
-    DisplayPlanePropertiesKHR& operator=( VkDisplayPlanePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPlanePropertiesKHR ) );
-      return *this;
-    }
     operator const VkDisplayPlanePropertiesKHR&() const
     {
       return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this);
@@ -5181,20 +5097,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct DisplayModePropertiesKHR
   {
-    DisplayModePropertiesKHR(  )
-    {
-    }
-
-    DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModePropertiesKHR ) );
-    }
-
-    DisplayModePropertiesKHR& operator=( VkDisplayModePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModePropertiesKHR ) );
-      return *this;
-    }
     operator const VkDisplayModePropertiesKHR&() const
     {
       return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this);
@@ -5653,20 +5555,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ShaderResourceUsageAMD
   {
-    ShaderResourceUsageAMD(  )
-    {
-    }
-
-    ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderResourceUsageAMD ) );
-    }
-
-    ShaderResourceUsageAMD& operator=( VkShaderResourceUsageAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderResourceUsageAMD ) );
-      return *this;
-    }
     operator const VkShaderResourceUsageAMD&() const
     {
       return *reinterpret_cast<const VkShaderResourceUsageAMD*>(this);
@@ -7034,9 +6922,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ApplicationInfo
   {
     ApplicationInfo( const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0 )
-      : sType( StructureType::eApplicationInfo )
-      , pNext( nullptr )
-      , pApplicationName( pApplicationName_ )
+      : pApplicationName( pApplicationName_ )
       , applicationVersion( applicationVersion_ )
       , pEngineName( pEngineName_ )
       , engineVersion( engineVersion_ )
@@ -7112,10 +6998,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eApplicationInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     const char* pApplicationName;
     uint32_t applicationVersion;
     const char* pEngineName;
@@ -7127,9 +7013,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceQueueCreateInfo
   {
     DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueCount_ = 0, const float* pQueuePriorities_ = nullptr )
-      : sType( StructureType::eDeviceQueueCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , queueFamilyIndex( queueFamilyIndex_ )
       , queueCount( queueCount_ )
       , pQueuePriorities( pQueuePriorities_ )
@@ -7197,10 +7081,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceQueueCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DeviceQueueCreateFlags flags;
     uint32_t queueFamilyIndex;
     uint32_t queueCount;
@@ -7211,9 +7095,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceCreateInfo
   {
     DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(), uint32_t queueCreateInfoCount_ = 0, const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr, const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
-      : sType( StructureType::eDeviceCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , queueCreateInfoCount( queueCreateInfoCount_ )
       , pQueueCreateInfos( pQueueCreateInfos_ )
       , enabledLayerCount( enabledLayerCount_ )
@@ -7313,10 +7195,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DeviceCreateFlags flags;
     uint32_t queueCreateInfoCount;
     const DeviceQueueCreateInfo* pQueueCreateInfos;
@@ -7331,9 +7213,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct InstanceCreateInfo
   {
     InstanceCreateInfo( InstanceCreateFlags flags_ = InstanceCreateFlags(), const ApplicationInfo* pApplicationInfo_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr )
-      : sType( StructureType::eInstanceCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , pApplicationInfo( pApplicationInfo_ )
       , enabledLayerCount( enabledLayerCount_ )
       , ppEnabledLayerNames( ppEnabledLayerNames_ )
@@ -7417,10 +7297,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eInstanceCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     InstanceCreateFlags flags;
     const ApplicationInfo* pApplicationInfo;
     uint32_t enabledLayerCount;
@@ -7433,9 +7313,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MemoryAllocateInfo
   {
     MemoryAllocateInfo( DeviceSize allocationSize_ = 0, uint32_t memoryTypeIndex_ = 0 )
-      : sType( StructureType::eMemoryAllocateInfo )
-      , pNext( nullptr )
-      , allocationSize( allocationSize_ )
+      : allocationSize( allocationSize_ )
       , memoryTypeIndex( memoryTypeIndex_ )
     {
     }
@@ -7487,10 +7365,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryAllocateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DeviceSize allocationSize;
     uint32_t memoryTypeIndex;
   };
@@ -7499,9 +7377,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MappedMemoryRange
   {
     MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(), DeviceSize offset_ = 0, DeviceSize size_ = 0 )
-      : sType( StructureType::eMappedMemoryRange )
-      , pNext( nullptr )
-      , memory( memory_ )
+      : memory( memory_ )
       , offset( offset_ )
       , size( size_ )
     {
@@ -7561,10 +7437,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMappedMemoryRange;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DeviceMemory memory;
     DeviceSize offset;
     DeviceSize size;
@@ -7574,9 +7450,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct WriteDescriptorSet
   {
     WriteDescriptorSet( DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, const DescriptorImageInfo* pImageInfo_ = nullptr, const DescriptorBufferInfo* pBufferInfo_ = nullptr, const BufferView* pTexelBufferView_ = nullptr )
-      : sType( StructureType::eWriteDescriptorSet )
-      , pNext( nullptr )
-      , dstSet( dstSet_ )
+      : dstSet( dstSet_ )
       , dstBinding( dstBinding_ )
       , dstArrayElement( dstArrayElement_ )
       , descriptorCount( descriptorCount_ )
@@ -7676,10 +7550,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eWriteDescriptorSet;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DescriptorSet dstSet;
     uint32_t dstBinding;
     uint32_t dstArrayElement;
@@ -7694,9 +7568,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct CopyDescriptorSet
   {
     CopyDescriptorSet( DescriptorSet srcSet_ = DescriptorSet(), uint32_t srcBinding_ = 0, uint32_t srcArrayElement_ = 0, DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0 )
-      : sType( StructureType::eCopyDescriptorSet )
-      , pNext( nullptr )
-      , srcSet( srcSet_ )
+      : srcSet( srcSet_ )
       , srcBinding( srcBinding_ )
       , srcArrayElement( srcArrayElement_ )
       , dstSet( dstSet_ )
@@ -7788,10 +7660,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eCopyDescriptorSet;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DescriptorSet srcSet;
     uint32_t srcBinding;
     uint32_t srcArrayElement;
@@ -7805,9 +7677,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BufferViewCreateInfo
   {
     BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(), Buffer buffer_ = Buffer(), Format format_ = Format::eUndefined, DeviceSize offset_ = 0, DeviceSize range_ = 0 )
-      : sType( StructureType::eBufferViewCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , buffer( buffer_ )
       , format( format_ )
       , offset( offset_ )
@@ -7883,10 +7753,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBufferViewCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     BufferViewCreateFlags flags;
     Buffer buffer;
     Format format;
@@ -7898,9 +7768,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ShaderModuleCreateInfo
   {
     ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(), size_t codeSize_ = 0, const uint32_t* pCode_ = nullptr )
-      : sType( StructureType::eShaderModuleCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , codeSize( codeSize_ )
       , pCode( pCode_ )
     {
@@ -7960,10 +7828,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eShaderModuleCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ShaderModuleCreateFlags flags;
     size_t codeSize;
     const uint32_t* pCode;
@@ -7973,9 +7841,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DescriptorSetAllocateInfo
   {
     DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(), uint32_t descriptorSetCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr )
-      : sType( StructureType::eDescriptorSetAllocateInfo )
-      , pNext( nullptr )
-      , descriptorPool( descriptorPool_ )
+      : descriptorPool( descriptorPool_ )
       , descriptorSetCount( descriptorSetCount_ )
       , pSetLayouts( pSetLayouts_ )
     {
@@ -8035,10 +7901,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDescriptorSetAllocateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DescriptorPool descriptorPool;
     uint32_t descriptorSetCount;
     const DescriptorSetLayout* pSetLayouts;
@@ -8048,9 +7914,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineVertexInputStateCreateInfo
   {
     PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_ = 0, const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, uint32_t vertexAttributeDescriptionCount_ = 0, const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
-      : sType( StructureType::ePipelineVertexInputStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
       , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
       , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
@@ -8126,10 +7990,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineVertexInputStateCreateFlags flags;
     uint32_t vertexBindingDescriptionCount;
     const VertexInputBindingDescription* pVertexBindingDescriptions;
@@ -8141,9 +8005,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineInputAssemblyStateCreateInfo
   {
     PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(), PrimitiveTopology topology_ = PrimitiveTopology::ePointList, Bool32 primitiveRestartEnable_ = 0 )
-      : sType( StructureType::ePipelineInputAssemblyStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , topology( topology_ )
       , primitiveRestartEnable( primitiveRestartEnable_ )
     {
@@ -8203,10 +8065,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineInputAssemblyStateCreateFlags flags;
     PrimitiveTopology topology;
     Bool32 primitiveRestartEnable;
@@ -8216,9 +8078,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineTessellationStateCreateInfo
   {
     PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_ = 0 )
-      : sType( StructureType::ePipelineTessellationStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , patchControlPoints( patchControlPoints_ )
     {
     }
@@ -8270,10 +8130,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineTessellationStateCreateFlags flags;
     uint32_t patchControlPoints;
   };
@@ -8282,9 +8142,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineViewportStateCreateInfo
   {
     PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(), uint32_t viewportCount_ = 0, const Viewport* pViewports_ = nullptr, uint32_t scissorCount_ = 0, const Rect2D* pScissors_ = nullptr )
-      : sType( StructureType::ePipelineViewportStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , viewportCount( viewportCount_ )
       , pViewports( pViewports_ )
       , scissorCount( scissorCount_ )
@@ -8360,10 +8218,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineViewportStateCreateFlags flags;
     uint32_t viewportCount;
     const Viewport* pViewports;
@@ -8375,9 +8233,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineRasterizationStateCreateInfo
   {
     PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = PipelineRasterizationStateCreateFlags(), Bool32 depthClampEnable_ = 0, Bool32 rasterizerDiscardEnable_ = 0, PolygonMode polygonMode_ = PolygonMode::eFill, CullModeFlags cullMode_ = CullModeFlags(), FrontFace frontFace_ = FrontFace::eCounterClockwise, Bool32 depthBiasEnable_ = 0, float depthBiasConstantFactor_ = 0, float depthBiasClamp_ = 0, float depthBiasSlopeFactor_ = 0, float lineWidth_ = 0 )
-      : sType( StructureType::ePipelineRasterizationStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , depthClampEnable( depthClampEnable_ )
       , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
       , polygonMode( polygonMode_ )
@@ -8501,10 +8357,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineRasterizationStateCreateFlags flags;
     Bool32 depthClampEnable;
     Bool32 rasterizerDiscardEnable;
@@ -8522,9 +8378,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineDepthStencilStateCreateInfo
   {
     PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(), Bool32 depthTestEnable_ = 0, Bool32 depthWriteEnable_ = 0, CompareOp depthCompareOp_ = CompareOp::eNever, Bool32 depthBoundsTestEnable_ = 0, Bool32 stencilTestEnable_ = 0, StencilOpState front_ = StencilOpState(), StencilOpState back_ = StencilOpState(), float minDepthBounds_ = 0, float maxDepthBounds_ = 0 )
-      : sType( StructureType::ePipelineDepthStencilStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , depthTestEnable( depthTestEnable_ )
       , depthWriteEnable( depthWriteEnable_ )
       , depthCompareOp( depthCompareOp_ )
@@ -8640,10 +8494,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineDepthStencilStateCreateFlags flags;
     Bool32 depthTestEnable;
     Bool32 depthWriteEnable;
@@ -8660,9 +8514,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineCacheCreateInfo
   {
     PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr )
-      : sType( StructureType::ePipelineCacheCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , initialDataSize( initialDataSize_ )
       , pInitialData( pInitialData_ )
     {
@@ -8722,10 +8574,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineCacheCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineCacheCreateFlags flags;
     size_t initialDataSize;
     const void* pInitialData;
@@ -8735,9 +8587,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SamplerCreateInfo
   {
     SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), Filter magFilter_ = Filter::eNearest, Filter minFilter_ = Filter::eNearest, SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, float mipLodBias_ = 0, Bool32 anisotropyEnable_ = 0, float maxAnisotropy_ = 0, Bool32 compareEnable_ = 0, CompareOp compareOp_ = CompareOp::eNever, float minLod_ = 0, float maxLod_ = 0, BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, Bool32 unnormalizedCoordinates_ = 0 )
-      : sType( StructureType::eSamplerCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , magFilter( magFilter_ )
       , minFilter( minFilter_ )
       , mipmapMode( mipmapMode_ )
@@ -8901,10 +8751,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSamplerCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SamplerCreateFlags flags;
     Filter magFilter;
     Filter minFilter;
@@ -8927,9 +8777,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct CommandBufferAllocateInfo
   {
     CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), CommandBufferLevel level_ = CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = 0 )
-      : sType( StructureType::eCommandBufferAllocateInfo )
-      , pNext( nullptr )
-      , commandPool( commandPool_ )
+      : commandPool( commandPool_ )
       , level( level_ )
       , commandBufferCount( commandBufferCount_ )
     {
@@ -8989,10 +8837,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eCommandBufferAllocateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     CommandPool commandPool;
     CommandBufferLevel level;
     uint32_t commandBufferCount;
@@ -9002,9 +8850,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct RenderPassBeginInfo
   {
     RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(), Framebuffer framebuffer_ = Framebuffer(), Rect2D renderArea_ = Rect2D(), uint32_t clearValueCount_ = 0, const ClearValue* pClearValues_ = nullptr )
-      : sType( StructureType::eRenderPassBeginInfo )
-      , pNext( nullptr )
-      , renderPass( renderPass_ )
+      : renderPass( renderPass_ )
       , framebuffer( framebuffer_ )
       , renderArea( renderArea_ )
       , clearValueCount( clearValueCount_ )
@@ -9080,10 +8926,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eRenderPassBeginInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     RenderPass renderPass;
     Framebuffer framebuffer;
     Rect2D renderArea;
@@ -9095,9 +8941,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct EventCreateInfo
   {
     EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() )
-      : sType( StructureType::eEventCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
     {
     }
 
@@ -9141,10 +8985,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eEventCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     EventCreateFlags flags;
   };
   static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
@@ -9152,9 +8996,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SemaphoreCreateInfo
   {
     SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() )
-      : sType( StructureType::eSemaphoreCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
     {
     }
 
@@ -9198,10 +9040,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSemaphoreCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SemaphoreCreateFlags flags;
   };
   static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
@@ -9209,9 +9051,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct FramebufferCreateInfo
   {
     FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(), RenderPass renderPass_ = RenderPass(), uint32_t attachmentCount_ = 0, const ImageView* pAttachments_ = nullptr, uint32_t width_ = 0, uint32_t height_ = 0, uint32_t layers_ = 0 )
-      : sType( StructureType::eFramebufferCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , renderPass( renderPass_ )
       , attachmentCount( attachmentCount_ )
       , pAttachments( pAttachments_ )
@@ -9303,10 +9143,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eFramebufferCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     FramebufferCreateFlags flags;
     RenderPass renderPass;
     uint32_t attachmentCount;
@@ -9320,9 +9160,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DisplayModeCreateInfoKHR
   {
     DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(), DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() )
-      : sType( StructureType::eDisplayModeCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , parameters( parameters_ )
     {
     }
@@ -9374,10 +9212,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DisplayModeCreateFlagsKHR flags;
     DisplayModeParametersKHR parameters;
   };
@@ -9386,9 +9224,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DisplayPresentInfoKHR
   {
     DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(), Rect2D dstRect_ = Rect2D(), Bool32 persistent_ = 0 )
-      : sType( StructureType::eDisplayPresentInfoKHR )
-      , pNext( nullptr )
-      , srcRect( srcRect_ )
+      : srcRect( srcRect_ )
       , dstRect( dstRect_ )
       , persistent( persistent_ )
     {
@@ -9448,10 +9284,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDisplayPresentInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Rect2D srcRect;
     Rect2D dstRect;
     Bool32 persistent;
@@ -9462,9 +9298,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct AndroidSurfaceCreateInfoKHR
   {
     AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(), ANativeWindow* window_ = nullptr )
-      : sType( StructureType::eAndroidSurfaceCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , window( window_ )
     {
     }
@@ -9516,10 +9350,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     AndroidSurfaceCreateFlagsKHR flags;
     ANativeWindow* window;
   };
@@ -9530,9 +9364,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MirSurfaceCreateInfoKHR
   {
     MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), MirConnection* connection_ = nullptr, MirSurface* mirSurface_ = nullptr )
-      : sType( StructureType::eMirSurfaceCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , connection( connection_ )
       , mirSurface( mirSurface_ )
     {
@@ -9592,10 +9424,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMirSurfaceCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     MirSurfaceCreateFlagsKHR flags;
     MirConnection* connection;
     MirSurface* mirSurface;
@@ -9607,9 +9439,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ViSurfaceCreateInfoNN
   {
     ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(), void* window_ = nullptr )
-      : sType( StructureType::eViSurfaceCreateInfoNN )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , window( window_ )
     {
     }
@@ -9661,10 +9491,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eViSurfaceCreateInfoNN;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ViSurfaceCreateFlagsNN flags;
     void* window;
   };
@@ -9675,9 +9505,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct WaylandSurfaceCreateInfoKHR
   {
     WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(), struct wl_display* display_ = nullptr, struct wl_surface* surface_ = nullptr )
-      : sType( StructureType::eWaylandSurfaceCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , display( display_ )
       , surface( surface_ )
     {
@@ -9737,10 +9565,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     WaylandSurfaceCreateFlagsKHR flags;
     struct wl_display* display;
     struct wl_surface* surface;
@@ -9752,9 +9580,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct Win32SurfaceCreateInfoKHR
   {
     Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(), HINSTANCE hinstance_ = 0, HWND hwnd_ = 0 )
-      : sType( StructureType::eWin32SurfaceCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , hinstance( hinstance_ )
       , hwnd( hwnd_ )
     {
@@ -9814,10 +9640,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Win32SurfaceCreateFlagsKHR flags;
     HINSTANCE hinstance;
     HWND hwnd;
@@ -9829,9 +9655,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct XlibSurfaceCreateInfoKHR
   {
     XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(), Display* dpy_ = nullptr, Window window_ = 0 )
-      : sType( StructureType::eXlibSurfaceCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , dpy( dpy_ )
       , window( window_ )
     {
@@ -9891,10 +9715,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     XlibSurfaceCreateFlagsKHR flags;
     Display* dpy;
     Window window;
@@ -9906,9 +9730,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct XcbSurfaceCreateInfoKHR
   {
     XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(), xcb_connection_t* connection_ = nullptr, xcb_window_t window_ = 0 )
-      : sType( StructureType::eXcbSurfaceCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , connection( connection_ )
       , window( window_ )
     {
@@ -9968,10 +9790,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     XcbSurfaceCreateFlagsKHR flags;
     xcb_connection_t* connection;
     xcb_window_t window;
@@ -9982,9 +9804,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DebugMarkerMarkerInfoEXT
   {
     DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } )
-      : sType( StructureType::eDebugMarkerMarkerInfoEXT )
-      , pNext( nullptr )
-      , pMarkerName( pMarkerName_ )
+      : pMarkerName( pMarkerName_ )
     {
       memcpy( &color, color_.data(), 4 * sizeof( float ) );
     }
@@ -10036,10 +9856,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     const char* pMarkerName;
     float color[4];
   };
@@ -10048,9 +9868,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DedicatedAllocationImageCreateInfoNV
   {
     DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
-      : sType( StructureType::eDedicatedAllocationImageCreateInfoNV )
-      , pNext( nullptr )
-      , dedicatedAllocation( dedicatedAllocation_ )
+      : dedicatedAllocation( dedicatedAllocation_ )
     {
     }
 
@@ -10094,10 +9912,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Bool32 dedicatedAllocation;
   };
   static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
@@ -10105,9 +9923,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DedicatedAllocationBufferCreateInfoNV
   {
     DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
-      : sType( StructureType::eDedicatedAllocationBufferCreateInfoNV )
-      , pNext( nullptr )
-      , dedicatedAllocation( dedicatedAllocation_ )
+      : dedicatedAllocation( dedicatedAllocation_ )
     {
     }
 
@@ -10151,10 +9967,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Bool32 dedicatedAllocation;
   };
   static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
@@ -10162,9 +9978,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DedicatedAllocationMemoryAllocateInfoNV
   {
     DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(), Buffer buffer_ = Buffer() )
-      : sType( StructureType::eDedicatedAllocationMemoryAllocateInfoNV )
-      , pNext( nullptr )
-      , image( image_ )
+      : image( image_ )
       , buffer( buffer_ )
     {
     }
@@ -10216,10 +10030,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Image image;
     Buffer buffer;
   };
@@ -10229,9 +10043,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExportMemoryWin32HandleInfoNV
   {
     ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 )
-      : sType( StructureType::eExportMemoryWin32HandleInfoNV )
-      , pNext( nullptr )
-      , pAttributes( pAttributes_ )
+      : pAttributes( pAttributes_ )
       , dwAccess( dwAccess_ )
     {
     }
@@ -10283,10 +10095,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     const SECURITY_ATTRIBUTES* pAttributes;
     DWORD dwAccess;
   };
@@ -10297,9 +10109,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct Win32KeyedMutexAcquireReleaseInfoNV
   {
     Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr )
-      : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoNV )
-      , pNext( nullptr )
-      , acquireCount( acquireCount_ )
+      : acquireCount( acquireCount_ )
       , pAcquireSyncs( pAcquireSyncs_ )
       , pAcquireKeys( pAcquireKeys_ )
       , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
@@ -10391,10 +10201,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t acquireCount;
     const DeviceMemory* pAcquireSyncs;
     const uint64_t* pAcquireKeys;
@@ -10409,9 +10219,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGeneratedCommandsFeaturesNVX
   {
     DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 )
-      : sType( StructureType::eDeviceGeneratedCommandsFeaturesNVX )
-      , pNext( nullptr )
-      , computeBindingPointSupport( computeBindingPointSupport_ )
+      : computeBindingPointSupport( computeBindingPointSupport_ )
     {
     }
 
@@ -10455,10 +10263,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Bool32 computeBindingPointSupport;
   };
   static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" );
@@ -10466,9 +10274,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGeneratedCommandsLimitsNVX
   {
     DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, uint32_t maxObjectEntryCounts_ = 0, uint32_t minSequenceCountBufferOffsetAlignment_ = 0, uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
-      : sType( StructureType::eDeviceGeneratedCommandsLimitsNVX )
-      , pNext( nullptr )
-      , maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
+      : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
       , maxObjectEntryCounts( maxObjectEntryCounts_ )
       , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
       , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
@@ -10544,10 +10350,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t maxIndirectCommandsLayoutTokenCount;
     uint32_t maxObjectEntryCounts;
     uint32_t minSequenceCountBufferOffsetAlignment;
@@ -10559,9 +10365,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct CmdReserveSpaceForCommandsInfoNVX
   {
     CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t maxSequencesCount_ = 0 )
-      : sType( StructureType::eCmdReserveSpaceForCommandsInfoNVX )
-      , pNext( nullptr )
-      , objectTable( objectTable_ )
+      : objectTable( objectTable_ )
       , indirectCommandsLayout( indirectCommandsLayout_ )
       , maxSequencesCount( maxSequencesCount_ )
     {
@@ -10621,10 +10425,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ObjectTableNVX objectTable;
     IndirectCommandsLayoutNVX indirectCommandsLayout;
     uint32_t maxSequencesCount;
@@ -10634,9 +10438,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceFeatures2KHR
   {
     PhysicalDeviceFeatures2KHR( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() )
-      : sType( StructureType::ePhysicalDeviceFeatures2KHR )
-      , pNext( nullptr )
-      , features( features_ )
+      : features( features_ )
     {
     }
 
@@ -10680,10 +10482,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceFeatures2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     PhysicalDeviceFeatures features;
   };
   static_assert( sizeof( PhysicalDeviceFeatures2KHR ) == sizeof( VkPhysicalDeviceFeatures2KHR ), "struct and wrapper have different size!" );
@@ -10691,9 +10493,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDevicePushDescriptorPropertiesKHR
   {
     PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 )
-      : sType( StructureType::ePhysicalDevicePushDescriptorPropertiesKHR )
-      , pNext( nullptr )
-      , maxPushDescriptors( maxPushDescriptors_ )
+      : maxPushDescriptors( maxPushDescriptors_ )
     {
     }
 
@@ -10737,10 +10537,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t maxPushDescriptors;
   };
   static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
@@ -10748,9 +10548,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PresentRegionsKHR
   {
     PresentRegionsKHR( uint32_t swapchainCount_ = 0, const PresentRegionKHR* pRegions_ = nullptr )
-      : sType( StructureType::ePresentRegionsKHR )
-      , pNext( nullptr )
-      , swapchainCount( swapchainCount_ )
+      : swapchainCount( swapchainCount_ )
       , pRegions( pRegions_ )
     {
     }
@@ -10802,10 +10600,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePresentRegionsKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t swapchainCount;
     const PresentRegionKHR* pRegions;
   };
@@ -10814,9 +10612,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceVariablePointerFeaturesKHR
   {
     PhysicalDeviceVariablePointerFeaturesKHR( Bool32 variablePointersStorageBuffer_ = 0, Bool32 variablePointers_ = 0 )
-      : sType( StructureType::ePhysicalDeviceVariablePointerFeaturesKHR )
-      , pNext( nullptr )
-      , variablePointersStorageBuffer( variablePointersStorageBuffer_ )
+      : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
       , variablePointers( variablePointers_ )
     {
     }
@@ -10868,10 +10664,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeaturesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 variablePointersStorageBuffer;
     Bool32 variablePointers;
   };
@@ -10879,22 +10675,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceIDPropertiesKHR
   {
-    PhysicalDeviceIDPropertiesKHR(  )
-      : sType( StructureType::ePhysicalDeviceIdPropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceIDPropertiesKHR( VkPhysicalDeviceIDPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceIDPropertiesKHR ) );
-    }
-
-    PhysicalDeviceIDPropertiesKHR& operator=( VkPhysicalDeviceIDPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceIDPropertiesKHR ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceIDPropertiesKHR&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceIDPropertiesKHR*>(this);
@@ -10917,10 +10697,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceIdPropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint8_t deviceUUID[VK_UUID_SIZE];
     uint8_t driverUUID[VK_UUID_SIZE];
     uint8_t deviceLUID[VK_LUID_SIZE_KHR];
@@ -10933,9 +10713,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExportMemoryWin32HandleInfoKHR
   {
     ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
-      : sType( StructureType::eExportMemoryWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , pAttributes( pAttributes_ )
+      : pAttributes( pAttributes_ )
       , dwAccess( dwAccess_ )
       , name( name_ )
     {
@@ -10995,10 +10773,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     const SECURITY_ATTRIBUTES* pAttributes;
     DWORD dwAccess;
     LPCWSTR name;
@@ -11009,22 +10787,6 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_WIN32_KHR
   struct MemoryWin32HandlePropertiesKHR
   {
-    MemoryWin32HandlePropertiesKHR(  )
-      : sType( StructureType::eMemoryWin32HandlePropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryWin32HandlePropertiesKHR ) );
-    }
-
-    MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryWin32HandlePropertiesKHR ) );
-      return *this;
-    }
     operator const VkMemoryWin32HandlePropertiesKHR&() const
     {
       return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(this);
@@ -11043,10 +10805,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t memoryTypeBits;
   };
   static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
@@ -11054,22 +10816,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct MemoryFdPropertiesKHR
   {
-    MemoryFdPropertiesKHR(  )
-      : sType( StructureType::eMemoryFdPropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryFdPropertiesKHR ) );
-    }
-
-    MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryFdPropertiesKHR ) );
-      return *this;
-    }
     operator const VkMemoryFdPropertiesKHR&() const
     {
       return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>(this);
@@ -11088,10 +10834,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryFdPropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t memoryTypeBits;
   };
   static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
@@ -11100,9 +10846,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct Win32KeyedMutexAcquireReleaseInfoKHR
   {
     Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr )
-      : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR )
-      , pNext( nullptr )
-      , acquireCount( acquireCount_ )
+      : acquireCount( acquireCount_ )
       , pAcquireSyncs( pAcquireSyncs_ )
       , pAcquireKeys( pAcquireKeys_ )
       , pAcquireTimeouts( pAcquireTimeouts_ )
@@ -11194,10 +10938,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t acquireCount;
     const DeviceMemory* pAcquireSyncs;
     const uint64_t* pAcquireKeys;
@@ -11213,9 +10957,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExportSemaphoreWin32HandleInfoKHR
   {
     ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
-      : sType( StructureType::eExportSemaphoreWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , pAttributes( pAttributes_ )
+      : pAttributes( pAttributes_ )
       , dwAccess( dwAccess_ )
       , name( name_ )
     {
@@ -11275,10 +11017,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     const SECURITY_ATTRIBUTES* pAttributes;
     DWORD dwAccess;
     LPCWSTR name;
@@ -11290,9 +11032,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct D3D12FenceSubmitInfoKHR
   {
     D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr )
-      : sType( StructureType::eD3D12FenceSubmitInfoKHR )
-      , pNext( nullptr )
-      , waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
+      : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
       , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
       , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
       , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
@@ -11360,10 +11100,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t waitSemaphoreValuesCount;
     const uint64_t* pWaitSemaphoreValues;
     uint32_t signalSemaphoreValuesCount;
@@ -11376,9 +11116,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExportFenceWin32HandleInfoKHR
   {
     ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
-      : sType( StructureType::eExportFenceWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , pAttributes( pAttributes_ )
+      : pAttributes( pAttributes_ )
       , dwAccess( dwAccess_ )
       , name( name_ )
     {
@@ -11438,10 +11176,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     const SECURITY_ATTRIBUTES* pAttributes;
     DWORD dwAccess;
     LPCWSTR name;
@@ -11452,9 +11190,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceMultiviewFeaturesKHX
   {
     PhysicalDeviceMultiviewFeaturesKHX( Bool32 multiview_ = 0, Bool32 multiviewGeometryShader_ = 0, Bool32 multiviewTessellationShader_ = 0 )
-      : sType( StructureType::ePhysicalDeviceMultiviewFeaturesKHX )
-      , pNext( nullptr )
-      , multiview( multiview_ )
+      : multiview( multiview_ )
       , multiviewGeometryShader( multiviewGeometryShader_ )
       , multiviewTessellationShader( multiviewTessellationShader_ )
     {
@@ -11514,10 +11250,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceMultiviewFeaturesKHX;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 multiview;
     Bool32 multiviewGeometryShader;
     Bool32 multiviewTessellationShader;
@@ -11526,22 +11262,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceMultiviewPropertiesKHX
   {
-    PhysicalDeviceMultiviewPropertiesKHX(  )
-      : sType( StructureType::ePhysicalDeviceMultiviewPropertiesKHX )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceMultiviewPropertiesKHX( VkPhysicalDeviceMultiviewPropertiesKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewPropertiesKHX ) );
-    }
-
-    PhysicalDeviceMultiviewPropertiesKHX& operator=( VkPhysicalDeviceMultiviewPropertiesKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewPropertiesKHX ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceMultiviewPropertiesKHX&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewPropertiesKHX*>(this);
@@ -11561,10 +11281,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceMultiviewPropertiesKHX;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t maxMultiviewViewCount;
     uint32_t maxMultiviewInstanceIndex;
   };
@@ -11573,9 +11293,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct RenderPassMultiviewCreateInfoKHX
   {
     RenderPassMultiviewCreateInfoKHX( uint32_t subpassCount_ = 0, const uint32_t* pViewMasks_ = nullptr, uint32_t dependencyCount_ = 0, const int32_t* pViewOffsets_ = nullptr, uint32_t correlationMaskCount_ = 0, const uint32_t* pCorrelationMasks_ = nullptr )
-      : sType( StructureType::eRenderPassMultiviewCreateInfoKHX )
-      , pNext( nullptr )
-      , subpassCount( subpassCount_ )
+      : subpassCount( subpassCount_ )
       , pViewMasks( pViewMasks_ )
       , dependencyCount( dependencyCount_ )
       , pViewOffsets( pViewOffsets_ )
@@ -11659,10 +11377,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eRenderPassMultiviewCreateInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t subpassCount;
     const uint32_t* pViewMasks;
     uint32_t dependencyCount;
@@ -11675,9 +11393,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BindBufferMemoryInfoKHR
   {
     BindBufferMemoryInfoKHR( Buffer buffer_ = Buffer(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 )
-      : sType( StructureType::eBindBufferMemoryInfoKHR )
-      , pNext( nullptr )
-      , buffer( buffer_ )
+      : buffer( buffer_ )
       , memory( memory_ )
       , memoryOffset( memoryOffset_ )
     {
@@ -11737,10 +11453,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBindBufferMemoryInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Buffer buffer;
     DeviceMemory memory;
     DeviceSize memoryOffset;
@@ -11750,9 +11466,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BindBufferMemoryDeviceGroupInfoKHX
   {
     BindBufferMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr )
-      : sType( StructureType::eBindBufferMemoryDeviceGroupInfoKHX )
-      , pNext( nullptr )
-      , deviceIndexCount( deviceIndexCount_ )
+      : deviceIndexCount( deviceIndexCount_ )
       , pDeviceIndices( pDeviceIndices_ )
     {
     }
@@ -11804,10 +11518,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t deviceIndexCount;
     const uint32_t* pDeviceIndices;
   };
@@ -11816,9 +11530,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BindImageMemoryInfoKHR
   {
     BindImageMemoryInfoKHR( Image image_ = Image(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 )
-      : sType( StructureType::eBindImageMemoryInfoKHR )
-      , pNext( nullptr )
-      , image( image_ )
+      : image( image_ )
       , memory( memory_ )
       , memoryOffset( memoryOffset_ )
     {
@@ -11878,10 +11590,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBindImageMemoryInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Image image;
     DeviceMemory memory;
     DeviceSize memoryOffset;
@@ -11891,9 +11603,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BindImageMemoryDeviceGroupInfoKHX
   {
     BindImageMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr, uint32_t SFRRectCount_ = 0, const Rect2D* pSFRRects_ = nullptr )
-      : sType( StructureType::eBindImageMemoryDeviceGroupInfoKHX )
-      , pNext( nullptr )
-      , deviceIndexCount( deviceIndexCount_ )
+      : deviceIndexCount( deviceIndexCount_ )
       , pDeviceIndices( pDeviceIndices_ )
       , SFRRectCount( SFRRectCount_ )
       , pSFRRects( pSFRRects_ )
@@ -11961,10 +11671,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t deviceIndexCount;
     const uint32_t* pDeviceIndices;
     uint32_t SFRRectCount;
@@ -11975,9 +11685,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGroupRenderPassBeginInfoKHX
   {
     DeviceGroupRenderPassBeginInfoKHX( uint32_t deviceMask_ = 0, uint32_t deviceRenderAreaCount_ = 0, const Rect2D* pDeviceRenderAreas_ = nullptr )
-      : sType( StructureType::eDeviceGroupRenderPassBeginInfoKHX )
-      , pNext( nullptr )
-      , deviceMask( deviceMask_ )
+      : deviceMask( deviceMask_ )
       , deviceRenderAreaCount( deviceRenderAreaCount_ )
       , pDeviceRenderAreas( pDeviceRenderAreas_ )
     {
@@ -12037,10 +11745,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t deviceMask;
     uint32_t deviceRenderAreaCount;
     const Rect2D* pDeviceRenderAreas;
@@ -12050,9 +11758,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGroupCommandBufferBeginInfoKHX
   {
     DeviceGroupCommandBufferBeginInfoKHX( uint32_t deviceMask_ = 0 )
-      : sType( StructureType::eDeviceGroupCommandBufferBeginInfoKHX )
-      , pNext( nullptr )
-      , deviceMask( deviceMask_ )
+      : deviceMask( deviceMask_ )
     {
     }
 
@@ -12096,10 +11802,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t deviceMask;
   };
   static_assert( sizeof( DeviceGroupCommandBufferBeginInfoKHX ) == sizeof( VkDeviceGroupCommandBufferBeginInfoKHX ), "struct and wrapper have different size!" );
@@ -12107,9 +11813,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGroupSubmitInfoKHX
   {
     DeviceGroupSubmitInfoKHX( uint32_t waitSemaphoreCount_ = 0, const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, uint32_t commandBufferCount_ = 0, const uint32_t* pCommandBufferDeviceMasks_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
-      : sType( StructureType::eDeviceGroupSubmitInfoKHX )
-      , pNext( nullptr )
-      , waitSemaphoreCount( waitSemaphoreCount_ )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
       , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
       , commandBufferCount( commandBufferCount_ )
       , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
@@ -12193,10 +11897,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGroupSubmitInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t waitSemaphoreCount;
     const uint32_t* pWaitSemaphoreDeviceIndices;
     uint32_t commandBufferCount;
@@ -12209,9 +11913,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGroupBindSparseInfoKHX
   {
     DeviceGroupBindSparseInfoKHX( uint32_t resourceDeviceIndex_ = 0, uint32_t memoryDeviceIndex_ = 0 )
-      : sType( StructureType::eDeviceGroupBindSparseInfoKHX )
-      , pNext( nullptr )
-      , resourceDeviceIndex( resourceDeviceIndex_ )
+      : resourceDeviceIndex( resourceDeviceIndex_ )
       , memoryDeviceIndex( memoryDeviceIndex_ )
     {
     }
@@ -12263,10 +11965,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGroupBindSparseInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t resourceDeviceIndex;
     uint32_t memoryDeviceIndex;
   };
@@ -12275,9 +11977,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageSwapchainCreateInfoKHX
   {
     ImageSwapchainCreateInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR() )
-      : sType( StructureType::eImageSwapchainCreateInfoKHX )
-      , pNext( nullptr )
-      , swapchain( swapchain_ )
+      : swapchain( swapchain_ )
     {
     }
 
@@ -12321,10 +12021,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageSwapchainCreateInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SwapchainKHR swapchain;
   };
   static_assert( sizeof( ImageSwapchainCreateInfoKHX ) == sizeof( VkImageSwapchainCreateInfoKHX ), "struct and wrapper have different size!" );
@@ -12332,9 +12032,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BindImageMemorySwapchainInfoKHX
   {
     BindImageMemorySwapchainInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint32_t imageIndex_ = 0 )
-      : sType( StructureType::eBindImageMemorySwapchainInfoKHX )
-      , pNext( nullptr )
-      , swapchain( swapchain_ )
+      : swapchain( swapchain_ )
       , imageIndex( imageIndex_ )
     {
     }
@@ -12386,10 +12084,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SwapchainKHR swapchain;
     uint32_t imageIndex;
   };
@@ -12398,9 +12096,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct AcquireNextImageInfoKHX
   {
     AcquireNextImageInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint64_t timeout_ = 0, Semaphore semaphore_ = Semaphore(), Fence fence_ = Fence(), uint32_t deviceMask_ = 0 )
-      : sType( StructureType::eAcquireNextImageInfoKHX )
-      , pNext( nullptr )
-      , swapchain( swapchain_ )
+      : swapchain( swapchain_ )
       , timeout( timeout_ )
       , semaphore( semaphore_ )
       , fence( fence_ )
@@ -12476,10 +12172,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eAcquireNextImageInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SwapchainKHR swapchain;
     uint64_t timeout;
     Semaphore semaphore;
@@ -12491,9 +12187,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct HdrMetadataEXT
   {
     HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(), XYColorEXT displayPrimaryGreen_ = XYColorEXT(), XYColorEXT displayPrimaryBlue_ = XYColorEXT(), XYColorEXT whitePoint_ = XYColorEXT(), float maxLuminance_ = 0, float minLuminance_ = 0, float maxContentLightLevel_ = 0, float maxFrameAverageLightLevel_ = 0 )
-      : sType( StructureType::eHdrMetadataEXT )
-      , pNext( nullptr )
-      , displayPrimaryRed( displayPrimaryRed_ )
+      : displayPrimaryRed( displayPrimaryRed_ )
       , displayPrimaryGreen( displayPrimaryGreen_ )
       , displayPrimaryBlue( displayPrimaryBlue_ )
       , whitePoint( whitePoint_ )
@@ -12593,10 +12287,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eHdrMetadataEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     XYColorEXT displayPrimaryRed;
     XYColorEXT displayPrimaryGreen;
     XYColorEXT displayPrimaryBlue;
@@ -12611,9 +12305,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PresentTimesInfoGOOGLE
   {
     PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, const PresentTimeGOOGLE* pTimes_ = nullptr )
-      : sType( StructureType::ePresentTimesInfoGOOGLE )
-      , pNext( nullptr )
-      , swapchainCount( swapchainCount_ )
+      : swapchainCount( swapchainCount_ )
       , pTimes( pTimes_ )
     {
     }
@@ -12665,10 +12357,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t swapchainCount;
     const PresentTimeGOOGLE* pTimes;
   };
@@ -12678,9 +12370,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct IOSSurfaceCreateInfoMVK
   {
     IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr )
-      : sType( StructureType::eIosSurfaceCreateInfoMVK )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , pView( pView_ )
     {
     }
@@ -12732,10 +12422,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     IOSSurfaceCreateFlagsMVK flags;
     const void* pView;
   };
@@ -12746,9 +12436,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MacOSSurfaceCreateInfoMVK
   {
     MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr )
-      : sType( StructureType::eMacosSurfaceCreateInfoMVK )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , pView( pView_ )
     {
     }
@@ -12800,10 +12488,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     MacOSSurfaceCreateFlagsMVK flags;
     const void* pView;
   };
@@ -12813,9 +12501,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineViewportWScalingStateCreateInfoNV
   {
     PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0, uint32_t viewportCount_ = 0, const ViewportWScalingNV* pViewportWScalings_ = nullptr )
-      : sType( StructureType::ePipelineViewportWScalingStateCreateInfoNV )
-      , pNext( nullptr )
-      , viewportWScalingEnable( viewportWScalingEnable_ )
+      : viewportWScalingEnable( viewportWScalingEnable_ )
       , viewportCount( viewportCount_ )
       , pViewportWScalings( pViewportWScalings_ )
     {
@@ -12875,10 +12561,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Bool32 viewportWScalingEnable;
     uint32_t viewportCount;
     const ViewportWScalingNV* pViewportWScalings;
@@ -12888,9 +12574,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceDiscardRectanglePropertiesEXT
   {
     PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 )
-      : sType( StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT )
-      , pNext( nullptr )
-      , maxDiscardRectangles( maxDiscardRectangles_ )
+      : maxDiscardRectangles( maxDiscardRectangles_ )
     {
     }
 
@@ -12934,32 +12618,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t maxDiscardRectangles;
   };
   static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
   {
-    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(  )
-      : sType( StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) );
-    }
-
-    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
@@ -12978,10 +12646,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 perViewPositionAllComponents;
   };
   static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
@@ -12989,9 +12657,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceSurfaceInfo2KHR
   {
     PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() )
-      : sType( StructureType::ePhysicalDeviceSurfaceInfo2KHR )
-      , pNext( nullptr )
-      , surface( surface_ )
+      : surface( surface_ )
     {
     }
 
@@ -13035,10 +12701,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SurfaceKHR surface;
   };
   static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
@@ -13046,9 +12712,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDevice16BitStorageFeaturesKHR
   {
     PhysicalDevice16BitStorageFeaturesKHR( Bool32 storageBuffer16BitAccess_ = 0, Bool32 uniformAndStorageBuffer16BitAccess_ = 0, Bool32 storagePushConstant16_ = 0, Bool32 storageInputOutput16_ = 0 )
-      : sType( StructureType::ePhysicalDevice16BitStorageFeaturesKHR )
-      , pNext( nullptr )
-      , storageBuffer16BitAccess( storageBuffer16BitAccess_ )
+      : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
       , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
       , storagePushConstant16( storagePushConstant16_ )
       , storageInputOutput16( storageInputOutput16_ )
@@ -13116,10 +12780,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDevice16BitStorageFeaturesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 storageBuffer16BitAccess;
     Bool32 uniformAndStorageBuffer16BitAccess;
     Bool32 storagePushConstant16;
@@ -13130,9 +12794,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BufferMemoryRequirementsInfo2KHR
   {
     BufferMemoryRequirementsInfo2KHR( Buffer buffer_ = Buffer() )
-      : sType( StructureType::eBufferMemoryRequirementsInfo2KHR )
-      , pNext( nullptr )
-      , buffer( buffer_ )
+      : buffer( buffer_ )
     {
     }
 
@@ -13176,10 +12838,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBufferMemoryRequirementsInfo2KHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Buffer buffer;
   };
   static_assert( sizeof( BufferMemoryRequirementsInfo2KHR ) == sizeof( VkBufferMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
@@ -13187,9 +12849,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageMemoryRequirementsInfo2KHR
   {
     ImageMemoryRequirementsInfo2KHR( Image image_ = Image() )
-      : sType( StructureType::eImageMemoryRequirementsInfo2KHR )
-      , pNext( nullptr )
-      , image( image_ )
+      : image( image_ )
     {
     }
 
@@ -13233,10 +12893,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageMemoryRequirementsInfo2KHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Image image;
   };
   static_assert( sizeof( ImageMemoryRequirementsInfo2KHR ) == sizeof( VkImageMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
@@ -13244,9 +12904,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageSparseMemoryRequirementsInfo2KHR
   {
     ImageSparseMemoryRequirementsInfo2KHR( Image image_ = Image() )
-      : sType( StructureType::eImageSparseMemoryRequirementsInfo2KHR )
-      , pNext( nullptr )
-      , image( image_ )
+      : image( image_ )
     {
     }
 
@@ -13290,32 +12948,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2KHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Image image;
   };
   static_assert( sizeof( ImageSparseMemoryRequirementsInfo2KHR ) == sizeof( VkImageSparseMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
 
   struct MemoryRequirements2KHR
   {
-    MemoryRequirements2KHR(  )
-      : sType( StructureType::eMemoryRequirements2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    MemoryRequirements2KHR( VkMemoryRequirements2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryRequirements2KHR ) );
-    }
-
-    MemoryRequirements2KHR& operator=( VkMemoryRequirements2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryRequirements2KHR ) );
-      return *this;
-    }
     operator const VkMemoryRequirements2KHR&() const
     {
       return *reinterpret_cast<const VkMemoryRequirements2KHR*>(this);
@@ -13334,32 +12976,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryRequirements2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     MemoryRequirements memoryRequirements;
   };
   static_assert( sizeof( MemoryRequirements2KHR ) == sizeof( VkMemoryRequirements2KHR ), "struct and wrapper have different size!" );
 
   struct MemoryDedicatedRequirementsKHR
   {
-    MemoryDedicatedRequirementsKHR(  )
-      : sType( StructureType::eMemoryDedicatedRequirementsKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    MemoryDedicatedRequirementsKHR( VkMemoryDedicatedRequirementsKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryDedicatedRequirementsKHR ) );
-    }
-
-    MemoryDedicatedRequirementsKHR& operator=( VkMemoryDedicatedRequirementsKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryDedicatedRequirementsKHR ) );
-      return *this;
-    }
     operator const VkMemoryDedicatedRequirementsKHR&() const
     {
       return *reinterpret_cast<const VkMemoryDedicatedRequirementsKHR*>(this);
@@ -13379,10 +13005,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryDedicatedRequirementsKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 prefersDedicatedAllocation;
     Bool32 requiresDedicatedAllocation;
   };
@@ -13391,9 +13017,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MemoryDedicatedAllocateInfoKHR
   {
     MemoryDedicatedAllocateInfoKHR( Image image_ = Image(), Buffer buffer_ = Buffer() )
-      : sType( StructureType::eMemoryDedicatedAllocateInfoKHR )
-      , pNext( nullptr )
-      , image( image_ )
+      : image( image_ )
       , buffer( buffer_ )
     {
     }
@@ -13445,10 +13069,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryDedicatedAllocateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Image image;
     Buffer buffer;
   };
@@ -13457,9 +13081,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SamplerYcbcrConversionInfoKHR
   {
     SamplerYcbcrConversionInfoKHR( SamplerYcbcrConversionKHR conversion_ = SamplerYcbcrConversionKHR() )
-      : sType( StructureType::eSamplerYcbcrConversionInfoKHR )
-      , pNext( nullptr )
-      , conversion( conversion_ )
+      : conversion( conversion_ )
     {
     }
 
@@ -13503,10 +13125,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSamplerYcbcrConversionInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SamplerYcbcrConversionKHR conversion;
   };
   static_assert( sizeof( SamplerYcbcrConversionInfoKHR ) == sizeof( VkSamplerYcbcrConversionInfoKHR ), "struct and wrapper have different size!" );
@@ -13514,9 +13136,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR
   {
     PhysicalDeviceSamplerYcbcrConversionFeaturesKHR( Bool32 samplerYcbcrConversion_ = 0 )
-      : sType( StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR )
-      , pNext( nullptr )
-      , samplerYcbcrConversion( samplerYcbcrConversion_ )
+      : samplerYcbcrConversion( samplerYcbcrConversion_ )
     {
     }
 
@@ -13560,32 +13180,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 samplerYcbcrConversion;
   };
   static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR ), "struct and wrapper have different size!" );
 
   struct SamplerYcbcrConversionImageFormatPropertiesKHR
   {
-    SamplerYcbcrConversionImageFormatPropertiesKHR(  )
-      : sType( StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    SamplerYcbcrConversionImageFormatPropertiesKHR( VkSamplerYcbcrConversionImageFormatPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) );
-    }
-
-    SamplerYcbcrConversionImageFormatPropertiesKHR& operator=( VkSamplerYcbcrConversionImageFormatPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) );
-      return *this;
-    }
     operator const VkSamplerYcbcrConversionImageFormatPropertiesKHR&() const
     {
       return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatPropertiesKHR*>(this);
@@ -13604,32 +13208,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t combinedImageSamplerDescriptorCount;
   };
   static_assert( sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) == sizeof( VkSamplerYcbcrConversionImageFormatPropertiesKHR ), "struct and wrapper have different size!" );
 
   struct TextureLODGatherFormatPropertiesAMD
   {
-    TextureLODGatherFormatPropertiesAMD(  )
-      : sType( StructureType::eTextureLodGatherFormatPropertiesAMD )
-      , pNext( nullptr )
-    {
-    }
-
-    TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( TextureLODGatherFormatPropertiesAMD ) );
-    }
-
-    TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( TextureLODGatherFormatPropertiesAMD ) );
-      return *this;
-    }
     operator const VkTextureLODGatherFormatPropertiesAMD&() const
     {
       return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(this);
@@ -13648,10 +13236,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 supportsTextureGatherLODBiasAMD;
   };
   static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
@@ -13659,9 +13247,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineCoverageToColorStateCreateInfoNV
   {
     PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 )
-      : sType( StructureType::ePipelineCoverageToColorStateCreateInfoNV )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , coverageToColorEnable( coverageToColorEnable_ )
       , coverageToColorLocation( coverageToColorLocation_ )
     {
@@ -13721,10 +13307,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineCoverageToColorStateCreateFlagsNV flags;
     Bool32 coverageToColorEnable;
     uint32_t coverageToColorLocation;
@@ -13733,22 +13319,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
   {
-    PhysicalDeviceSamplerFilterMinmaxPropertiesEXT(  )
-      : sType( StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) );
-    }
-
-    PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
@@ -13768,10 +13338,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 filterMinmaxSingleComponentFormats;
     Bool32 filterMinmaxImageComponentMapping;
   };
@@ -13779,22 +13349,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct MultisamplePropertiesEXT
   {
-    MultisamplePropertiesEXT(  )
-      : sType( StructureType::eMultisamplePropertiesEXT )
-      , pNext( nullptr )
-    {
-    }
-
-    MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MultisamplePropertiesEXT ) );
-    }
-
-    MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MultisamplePropertiesEXT ) );
-      return *this;
-    }
     operator const VkMultisamplePropertiesEXT&() const
     {
       return *reinterpret_cast<const VkMultisamplePropertiesEXT*>(this);
@@ -13813,10 +13367,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMultisamplePropertiesEXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Extent2D maxSampleLocationGridSize;
   };
   static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
@@ -13824,9 +13378,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
   {
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 )
-      : sType( StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT )
-      , pNext( nullptr )
-      , advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
+      : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
     {
     }
 
@@ -13870,32 +13422,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     Bool32 advancedBlendCoherentOperations;
   };
   static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
   {
-    PhysicalDeviceBlendOperationAdvancedPropertiesEXT(  )
-      : sType( StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) );
-    }
-
-    PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
@@ -13919,10 +13455,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t advancedBlendMaxColorAttachments;
     Bool32 advancedBlendIndependentBlend;
     Bool32 advancedBlendNonPremultipliedSrcColor;
@@ -13935,9 +13471,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageFormatListCreateInfoKHR
   {
     ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, const Format* pViewFormats_ = nullptr )
-      : sType( StructureType::eImageFormatListCreateInfoKHR )
-      , pNext( nullptr )
-      , viewFormatCount( viewFormatCount_ )
+      : viewFormatCount( viewFormatCount_ )
       , pViewFormats( pViewFormats_ )
     {
     }
@@ -13989,10 +13523,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t viewFormatCount;
     const Format* pViewFormats;
   };
@@ -14001,9 +13535,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ValidationCacheCreateInfoEXT
   {
     ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr )
-      : sType( StructureType::eValidationCacheCreateInfoEXT )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , initialDataSize( initialDataSize_ )
       , pInitialData( pInitialData_ )
     {
@@ -14063,10 +13595,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ValidationCacheCreateFlagsEXT flags;
     size_t initialDataSize;
     const void* pInitialData;
@@ -14076,9 +13608,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ShaderModuleValidationCacheCreateInfoEXT
   {
     ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() )
-      : sType( StructureType::eShaderModuleValidationCacheCreateInfoEXT )
-      , pNext( nullptr )
-      , validationCache( validationCache_ )
+      : validationCache( validationCache_ )
     {
     }
 
@@ -14122,10 +13652,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ValidationCacheEXT validationCache;
   };
   static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
@@ -14133,9 +13663,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MemoryHostPointerPropertiesEXT
   {
     MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 )
-      : sType( StructureType::eMemoryHostPointerPropertiesEXT )
-      , pNext( nullptr )
-      , memoryTypeBits( memoryTypeBits_ )
+      : memoryTypeBits( memoryTypeBits_ )
     {
     }
 
@@ -14179,10 +13707,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t memoryTypeBits;
   };
   static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
@@ -14190,9 +13718,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceExternalMemoryHostPropertiesEXT
   {
     PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 )
-      : sType( StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT )
-      , pNext( nullptr )
-      , minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
+      : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
     {
     }
 
@@ -14236,10 +13762,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     DeviceSize minImportedHostPointerAlignment;
   };
   static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
@@ -14253,9 +13779,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PresentInfoKHR
   {
     PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t swapchainCount_ = 0, const SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, Result* pResults_ = nullptr )
-      : sType( StructureType::ePresentInfoKHR )
-      , pNext( nullptr )
-      , waitSemaphoreCount( waitSemaphoreCount_ )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
       , pWaitSemaphores( pWaitSemaphores_ )
       , swapchainCount( swapchainCount_ )
       , pSwapchains( pSwapchains_ )
@@ -14339,10 +13863,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePresentInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t waitSemaphoreCount;
     const Semaphore* pWaitSemaphores;
     uint32_t swapchainCount;
@@ -14371,9 +13895,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineDynamicStateCreateInfo
   {
     PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr )
-      : sType( StructureType::ePipelineDynamicStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , dynamicStateCount( dynamicStateCount_ )
       , pDynamicStates( pDynamicStates_ )
     {
@@ -14433,10 +13955,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineDynamicStateCreateFlags flags;
     uint32_t dynamicStateCount;
     const DynamicState* pDynamicStates;
@@ -14452,9 +13974,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DescriptorUpdateTemplateCreateInfoKHR
   {
     DescriptorUpdateTemplateCreateInfoKHR( DescriptorUpdateTemplateCreateFlagsKHR flags_ = DescriptorUpdateTemplateCreateFlagsKHR(), uint32_t descriptorUpdateEntryCount_ = 0, const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ = nullptr, DescriptorUpdateTemplateTypeKHR templateType_ = DescriptorUpdateTemplateTypeKHR::eDescriptorSet, DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, PipelineLayout pipelineLayout_ = PipelineLayout(), uint32_t set_ = 0 )
-      : sType( StructureType::eDescriptorUpdateTemplateCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
       , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
       , templateType( templateType_ )
@@ -14554,10 +14074,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfoKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     DescriptorUpdateTemplateCreateFlagsKHR flags;
     uint32_t descriptorUpdateEntryCount;
     const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries;
@@ -14639,20 +14159,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct QueueFamilyProperties
   {
-    QueueFamilyProperties(  )
-    {
-    }
-
-    QueueFamilyProperties( VkQueueFamilyProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( QueueFamilyProperties ) );
-    }
-
-    QueueFamilyProperties& operator=( VkQueueFamilyProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( QueueFamilyProperties ) );
-      return *this;
-    }
     operator const VkQueueFamilyProperties&() const
     {
       return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
@@ -14680,22 +14186,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct QueueFamilyProperties2KHR
   {
-    QueueFamilyProperties2KHR(  )
-      : sType( StructureType::eQueueFamilyProperties2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    QueueFamilyProperties2KHR( VkQueueFamilyProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( QueueFamilyProperties2KHR ) );
-    }
-
-    QueueFamilyProperties2KHR& operator=( VkQueueFamilyProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( QueueFamilyProperties2KHR ) );
-      return *this;
-    }
     operator const VkQueueFamilyProperties2KHR&() const
     {
       return *reinterpret_cast<const VkQueueFamilyProperties2KHR*>(this);
@@ -14714,10 +14204,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eQueueFamilyProperties2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     QueueFamilyProperties queueFamilyProperties;
   };
   static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" );
@@ -14753,20 +14243,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct MemoryType
   {
-    MemoryType(  )
-    {
-    }
-
-    MemoryType( VkMemoryType const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryType ) );
-    }
-
-    MemoryType& operator=( VkMemoryType const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryType ) );
-      return *this;
-    }
     operator const VkMemoryType&() const
     {
       return *reinterpret_cast<const VkMemoryType*>(this);
@@ -14816,20 +14292,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct MemoryHeap
   {
-    MemoryHeap(  )
-    {
-    }
-
-    MemoryHeap( VkMemoryHeap const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryHeap ) );
-    }
-
-    MemoryHeap& operator=( VkMemoryHeap const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryHeap ) );
-      return *this;
-    }
     operator const VkMemoryHeap&() const
     {
       return *reinterpret_cast<const VkMemoryHeap*>(this);
@@ -14853,20 +14315,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceMemoryProperties
   {
-    PhysicalDeviceMemoryProperties(  )
-    {
-    }
-
-    PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryProperties ) );
-    }
-
-    PhysicalDeviceMemoryProperties& operator=( VkPhysicalDeviceMemoryProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryProperties ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceMemoryProperties&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
@@ -14894,22 +14342,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceMemoryProperties2KHR
   {
-    PhysicalDeviceMemoryProperties2KHR(  )
-      : sType( StructureType::ePhysicalDeviceMemoryProperties2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceMemoryProperties2KHR( VkPhysicalDeviceMemoryProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryProperties2KHR ) );
-    }
-
-    PhysicalDeviceMemoryProperties2KHR& operator=( VkPhysicalDeviceMemoryProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryProperties2KHR ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceMemoryProperties2KHR&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2KHR*>(this);
@@ -14928,10 +14360,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     PhysicalDeviceMemoryProperties memoryProperties;
   };
   static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" );
@@ -14983,9 +14415,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MemoryBarrier
   {
     MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() )
-      : sType( StructureType::eMemoryBarrier )
-      , pNext( nullptr )
-      , srcAccessMask( srcAccessMask_ )
+      : srcAccessMask( srcAccessMask_ )
       , dstAccessMask( dstAccessMask_ )
     {
     }
@@ -15037,10 +14467,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryBarrier;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     AccessFlags srcAccessMask;
     AccessFlags dstAccessMask;
   };
@@ -15049,9 +14479,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BufferMemoryBarrier
   {
     BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize size_ = 0 )
-      : sType( StructureType::eBufferMemoryBarrier )
-      , pNext( nullptr )
-      , srcAccessMask( srcAccessMask_ )
+      : srcAccessMask( srcAccessMask_ )
       , dstAccessMask( dstAccessMask_ )
       , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
       , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
@@ -15143,10 +14571,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBufferMemoryBarrier;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     AccessFlags srcAccessMask;
     AccessFlags dstAccessMask;
     uint32_t srcQueueFamilyIndex;
@@ -15220,9 +14648,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BufferCreateInfo
   {
     BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), DeviceSize size_ = 0, BufferUsageFlags usage_ = BufferUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr )
-      : sType( StructureType::eBufferCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , size( size_ )
       , usage( usage_ )
       , sharingMode( sharingMode_ )
@@ -15306,10 +14732,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBufferCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     BufferCreateFlags flags;
     DeviceSize size;
     BufferUsageFlags usage;
@@ -15432,9 +14858,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineShaderStageCreateInfo
   {
     PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr )
-      : sType( StructureType::ePipelineShaderStageCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , stage( stage_ )
       , module( module_ )
       , pName( pName_ )
@@ -15510,10 +14934,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineShaderStageCreateFlags flags;
     ShaderStageFlagBits stage;
     ShaderModule module;
@@ -15585,9 +15009,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineLayoutCreateInfo
   {
     PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr )
-      : sType( StructureType::ePipelineLayoutCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , setLayoutCount( setLayoutCount_ )
       , pSetLayouts( pSetLayouts_ )
       , pushConstantRangeCount( pushConstantRangeCount_ )
@@ -15663,10 +15085,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineLayoutCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineLayoutCreateFlags flags;
     uint32_t setLayoutCount;
     const DescriptorSetLayout* pSetLayouts;
@@ -15677,20 +15099,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ShaderStatisticsInfoAMD
   {
-    ShaderStatisticsInfoAMD(  )
-    {
-    }
-
-    ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderStatisticsInfoAMD ) );
-    }
-
-    ShaderStatisticsInfoAMD& operator=( VkShaderStatisticsInfoAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderStatisticsInfoAMD ) );
-      return *this;
-    }
     operator const VkShaderStatisticsInfoAMD&() const
     {
       return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>(this);
@@ -15756,22 +15164,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SharedPresentSurfaceCapabilitiesKHR
   {
-    SharedPresentSurfaceCapabilitiesKHR(  )
-      : sType( StructureType::eSharedPresentSurfaceCapabilitiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SharedPresentSurfaceCapabilitiesKHR ) );
-    }
-
-    SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SharedPresentSurfaceCapabilitiesKHR ) );
-      return *this;
-    }
     operator const VkSharedPresentSurfaceCapabilitiesKHR&() const
     {
       return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(this);
@@ -15790,10 +15182,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     ImageUsageFlags sharedPresentSupportedUsageFlags;
   };
   static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
@@ -15801,9 +15193,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageViewUsageCreateInfoKHR
   {
     ImageViewUsageCreateInfoKHR( ImageUsageFlags usage_ = ImageUsageFlags() )
-      : sType( StructureType::eImageViewUsageCreateInfoKHR )
-      , pNext( nullptr )
-      , usage( usage_ )
+      : usage( usage_ )
     {
     }
 
@@ -15847,10 +15237,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageViewUsageCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ImageUsageFlags usage;
   };
   static_assert( sizeof( ImageViewUsageCreateInfoKHR ) == sizeof( VkImageViewUsageCreateInfoKHR ), "struct and wrapper have different size!" );
@@ -15894,9 +15284,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceImageFormatInfo2KHR
   {
     PhysicalDeviceImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() )
-      : sType( StructureType::ePhysicalDeviceImageFormatInfo2KHR )
-      , pNext( nullptr )
-      , format( format_ )
+      : format( format_ )
       , type( type_ )
       , tiling( tiling_ )
       , usage( usage_ )
@@ -15972,10 +15360,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2KHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Format format;
     ImageType type;
     ImageTiling tiling;
@@ -16016,9 +15404,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ComputePipelineCreateInfo
   {
     ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), PipelineLayout layout_ = PipelineLayout(), Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 )
-      : sType( StructureType::eComputePipelineCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , stage( stage_ )
       , layout( layout_ )
       , basePipelineHandle( basePipelineHandle_ )
@@ -16094,10 +15480,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eComputePipelineCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineCreateFlags flags;
     PipelineShaderStageCreateInfo stage;
     PipelineLayout layout;
@@ -16242,9 +15628,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineColorBlendStateCreateInfo
   {
     PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), Bool32 logicOpEnable_ = 0, LogicOp logicOp_ = LogicOp::eClear, uint32_t attachmentCount_ = 0, const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array<float,4> const& blendConstants_ = { { 0, 0, 0, 0 } } )
-      : sType( StructureType::ePipelineColorBlendStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , logicOpEnable( logicOpEnable_ )
       , logicOp( logicOp_ )
       , attachmentCount( attachmentCount_ )
@@ -16328,10 +15712,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineColorBlendStateCreateFlags flags;
     Bool32 logicOpEnable;
     LogicOp logicOp;
@@ -16369,9 +15753,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct FenceCreateInfo
   {
     FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
-      : sType( StructureType::eFenceCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
     {
     }
 
@@ -16415,10 +15797,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eFenceCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     FenceCreateFlags flags;
   };
   static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
@@ -16473,20 +15855,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct FormatProperties
   {
-    FormatProperties(  )
-    {
-    }
-
-    FormatProperties( VkFormatProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FormatProperties ) );
-    }
-
-    FormatProperties& operator=( VkFormatProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FormatProperties ) );
-      return *this;
-    }
     operator const VkFormatProperties&() const
     {
       return *reinterpret_cast<const VkFormatProperties*>(this);
@@ -16512,22 +15880,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct FormatProperties2KHR
   {
-    FormatProperties2KHR(  )
-      : sType( StructureType::eFormatProperties2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    FormatProperties2KHR( VkFormatProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FormatProperties2KHR ) );
-    }
-
-    FormatProperties2KHR& operator=( VkFormatProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FormatProperties2KHR ) );
-      return *this;
-    }
     operator const VkFormatProperties2KHR&() const
     {
       return *reinterpret_cast<const VkFormatProperties2KHR*>(this);
@@ -16546,10 +15898,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eFormatProperties2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     FormatProperties formatProperties;
   };
   static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" );
@@ -16672,9 +16024,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct CommandBufferInheritanceInfo
   {
     CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
-      : sType( StructureType::eCommandBufferInheritanceInfo )
-      , pNext( nullptr )
-      , renderPass( renderPass_ )
+      : renderPass( renderPass_ )
       , subpass( subpass_ )
       , framebuffer( framebuffer_ )
       , occlusionQueryEnable( occlusionQueryEnable_ )
@@ -16758,10 +16108,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eCommandBufferInheritanceInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     RenderPass renderPass;
     uint32_t subpass;
     Framebuffer framebuffer;
@@ -16774,9 +16124,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct CommandBufferBeginInfo
   {
     CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
-      : sType( StructureType::eCommandBufferBeginInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , pInheritanceInfo( pInheritanceInfo_ )
     {
     }
@@ -16828,10 +16176,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eCommandBufferBeginInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     CommandBufferUsageFlags flags;
     const CommandBufferInheritanceInfo* pInheritanceInfo;
   };
@@ -16840,9 +16188,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct QueryPoolCreateInfo
   {
     QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
-      : sType( StructureType::eQueryPoolCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , queryType( queryType_ )
       , queryCount( queryCount_ )
       , pipelineStatistics( pipelineStatistics_ )
@@ -16910,10 +16256,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eQueryPoolCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     QueryPoolCreateFlags flags;
     QueryType queryType;
     uint32_t queryCount;
@@ -17162,9 +16508,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageMemoryBarrier
   {
     ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), ImageLayout oldLayout_ = ImageLayout::eUndefined, ImageLayout newLayout_ = ImageLayout::eUndefined, uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Image image_ = Image(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
-      : sType( StructureType::eImageMemoryBarrier )
-      , pNext( nullptr )
-      , srcAccessMask( srcAccessMask_ )
+      : srcAccessMask( srcAccessMask_ )
       , dstAccessMask( dstAccessMask_ )
       , oldLayout( oldLayout_ )
       , newLayout( newLayout_ )
@@ -17264,10 +16608,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageMemoryBarrier;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     AccessFlags srcAccessMask;
     AccessFlags dstAccessMask;
     ImageLayout oldLayout;
@@ -17282,9 +16626,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageViewCreateInfo
   {
     ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
-      : sType( StructureType::eImageViewCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , image( image_ )
       , viewType( viewType_ )
       , format( format_ )
@@ -17368,10 +16710,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageViewCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ImageViewCreateFlags flags;
     Image image;
     ImageViewType viewType;
@@ -17804,9 +17146,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct RenderPassInputAttachmentAspectCreateInfoKHR
   {
     RenderPassInputAttachmentAspectCreateInfoKHR( uint32_t aspectReferenceCount_ = 0, const InputAttachmentAspectReferenceKHR* pAspectReferences_ = nullptr )
-      : sType( StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR )
-      , pNext( nullptr )
-      , aspectReferenceCount( aspectReferenceCount_ )
+      : aspectReferenceCount( aspectReferenceCount_ )
       , pAspectReferences( pAspectReferences_ )
     {
     }
@@ -17858,10 +17198,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t aspectReferenceCount;
     const InputAttachmentAspectReferenceKHR* pAspectReferences;
   };
@@ -17870,9 +17210,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BindImagePlaneMemoryInfoKHR
   {
     BindImagePlaneMemoryInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
-      : sType( StructureType::eBindImagePlaneMemoryInfoKHR )
-      , pNext( nullptr )
-      , planeAspect( planeAspect_ )
+      : planeAspect( planeAspect_ )
     {
     }
 
@@ -17916,10 +17254,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBindImagePlaneMemoryInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ImageAspectFlagBits planeAspect;
   };
   static_assert( sizeof( BindImagePlaneMemoryInfoKHR ) == sizeof( VkBindImagePlaneMemoryInfoKHR ), "struct and wrapper have different size!" );
@@ -17927,9 +17265,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImagePlaneMemoryRequirementsInfoKHR
   {
     ImagePlaneMemoryRequirementsInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
-      : sType( StructureType::eImagePlaneMemoryRequirementsInfoKHR )
-      , pNext( nullptr )
-      , planeAspect( planeAspect_ )
+      : planeAspect( planeAspect_ )
     {
     }
 
@@ -17973,10 +17309,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ImageAspectFlagBits planeAspect;
   };
   static_assert( sizeof( ImagePlaneMemoryRequirementsInfoKHR ) == sizeof( VkImagePlaneMemoryRequirementsInfoKHR ), "struct and wrapper have different size!" );
@@ -18010,20 +17346,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SparseImageFormatProperties
   {
-    SparseImageFormatProperties(  )
-    {
-    }
-
-    SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageFormatProperties ) );
-    }
-
-    SparseImageFormatProperties& operator=( VkSparseImageFormatProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageFormatProperties ) );
-      return *this;
-    }
     operator const VkSparseImageFormatProperties&() const
     {
       return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
@@ -18049,20 +17371,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SparseImageMemoryRequirements
   {
-    SparseImageMemoryRequirements(  )
-    {
-    }
-
-    SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryRequirements ) );
-    }
-
-    SparseImageMemoryRequirements& operator=( VkSparseImageMemoryRequirements const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryRequirements ) );
-      return *this;
-    }
     operator const VkSparseImageMemoryRequirements&() const
     {
       return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
@@ -18092,22 +17400,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SparseImageFormatProperties2KHR
   {
-    SparseImageFormatProperties2KHR(  )
-      : sType( StructureType::eSparseImageFormatProperties2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    SparseImageFormatProperties2KHR( VkSparseImageFormatProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageFormatProperties2KHR ) );
-    }
-
-    SparseImageFormatProperties2KHR& operator=( VkSparseImageFormatProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageFormatProperties2KHR ) );
-      return *this;
-    }
     operator const VkSparseImageFormatProperties2KHR&() const
     {
       return *reinterpret_cast<const VkSparseImageFormatProperties2KHR*>(this);
@@ -18126,32 +17418,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSparseImageFormatProperties2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     SparseImageFormatProperties properties;
   };
   static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" );
 
   struct SparseImageMemoryRequirements2KHR
   {
-    SparseImageMemoryRequirements2KHR(  )
-      : sType( StructureType::eSparseImageMemoryRequirements2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    SparseImageMemoryRequirements2KHR( VkSparseImageMemoryRequirements2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryRequirements2KHR ) );
-    }
-
-    SparseImageMemoryRequirements2KHR& operator=( VkSparseImageMemoryRequirements2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryRequirements2KHR ) );
-      return *this;
-    }
     operator const VkSparseImageMemoryRequirements2KHR&() const
     {
       return *reinterpret_cast<const VkSparseImageMemoryRequirements2KHR*>(this);
@@ -18170,10 +17446,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSparseImageMemoryRequirements2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     SparseImageMemoryRequirements memoryRequirements;
   };
   static_assert( sizeof( SparseImageMemoryRequirements2KHR ) == sizeof( VkSparseImageMemoryRequirements2KHR ), "struct and wrapper have different size!" );
@@ -18551,9 +17827,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct BindSparseInfo
   {
     BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t bufferBindCount_ = 0, const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, uint32_t imageOpaqueBindCount_ = 0, const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, uint32_t imageBindCount_ = 0, const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr )
-      : sType( StructureType::eBindSparseInfo )
-      , pNext( nullptr )
-      , waitSemaphoreCount( waitSemaphoreCount_ )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
       , pWaitSemaphores( pWaitSemaphores_ )
       , bufferBindCount( bufferBindCount_ )
       , pBufferBinds( pBufferBinds_ )
@@ -18669,10 +17943,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eBindSparseInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t waitSemaphoreCount;
     const Semaphore* pWaitSemaphores;
     uint32_t bufferBindCount;
@@ -18757,9 +18031,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct CommandPoolCreateInfo
   {
     CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 )
-      : sType( StructureType::eCommandPoolCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , queueFamilyIndex( queueFamilyIndex_ )
     {
     }
@@ -18811,10 +18083,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eCommandPoolCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     CommandPoolCreateFlags flags;
     uint32_t queueFamilyIndex;
   };
@@ -18903,20 +18175,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ImageFormatProperties
   {
-    ImageFormatProperties(  )
-    {
-    }
-
-    ImageFormatProperties( VkImageFormatProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageFormatProperties ) );
-    }
-
-    ImageFormatProperties& operator=( VkImageFormatProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageFormatProperties ) );
-      return *this;
-    }
     operator const VkImageFormatProperties&() const
     {
       return *reinterpret_cast<const VkImageFormatProperties*>(this);
@@ -18947,9 +18205,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageCreateInfo
   {
     ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), ImageType imageType_ = ImageType::e1D, Format format_ = Format::eUndefined, Extent3D extent_ = Extent3D(), uint32_t mipLevels_ = 0, uint32_t arrayLayers_ = 0, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, ImageLayout initialLayout_ = ImageLayout::eUndefined )
-      : sType( StructureType::eImageCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , imageType( imageType_ )
       , format( format_ )
       , extent( extent_ )
@@ -19089,10 +18345,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ImageCreateFlags flags;
     ImageType imageType;
     Format format;
@@ -19112,9 +18368,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineMultisampleStateCreateInfo
   {
     PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, Bool32 sampleShadingEnable_ = 0, float minSampleShading_ = 0, const SampleMask* pSampleMask_ = nullptr, Bool32 alphaToCoverageEnable_ = 0, Bool32 alphaToOneEnable_ = 0 )
-      : sType( StructureType::ePipelineMultisampleStateCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , rasterizationSamples( rasterizationSamples_ )
       , sampleShadingEnable( sampleShadingEnable_ )
       , minSampleShading( minSampleShading_ )
@@ -19206,10 +18460,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineMultisampleStateCreateFlags flags;
     SampleCountFlagBits rasterizationSamples;
     Bool32 sampleShadingEnable;
@@ -19223,9 +18477,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct GraphicsPipelineCreateInfo
   {
     GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), uint32_t stageCount_ = 0, const PipelineShaderStageCreateInfo* pStages_ = nullptr, const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, PipelineLayout layout_ = PipelineLayout(), RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 )
-      : sType( StructureType::eGraphicsPipelineCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , stageCount( stageCount_ )
       , pStages( pStages_ )
       , pVertexInputState( pVertexInputState_ )
@@ -19397,10 +18649,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineCreateFlags flags;
     uint32_t stageCount;
     const PipelineShaderStageCreateInfo* pStages;
@@ -19423,20 +18675,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceLimits
   {
-    PhysicalDeviceLimits(  )
-    {
-    }
-
-    PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceLimits ) );
-    }
-
-    PhysicalDeviceLimits& operator=( VkPhysicalDeviceLimits const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceLimits ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceLimits&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
@@ -19668,20 +18906,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceProperties
   {
-    PhysicalDeviceProperties(  )
-    {
-    }
-
-    PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceProperties ) );
-    }
-
-    PhysicalDeviceProperties& operator=( VkPhysicalDeviceProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceProperties ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceProperties&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
@@ -19719,22 +18943,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceProperties2KHR
   {
-    PhysicalDeviceProperties2KHR(  )
-      : sType( StructureType::ePhysicalDeviceProperties2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceProperties2KHR( VkPhysicalDeviceProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceProperties2KHR ) );
-    }
-
-    PhysicalDeviceProperties2KHR& operator=( VkPhysicalDeviceProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceProperties2KHR ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceProperties2KHR&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceProperties2KHR*>(this);
@@ -19753,32 +18961,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceProperties2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     PhysicalDeviceProperties properties;
   };
   static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" );
 
   struct ImageFormatProperties2KHR
   {
-    ImageFormatProperties2KHR(  )
-      : sType( StructureType::eImageFormatProperties2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    ImageFormatProperties2KHR( VkImageFormatProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageFormatProperties2KHR ) );
-    }
-
-    ImageFormatProperties2KHR& operator=( VkImageFormatProperties2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageFormatProperties2KHR ) );
-      return *this;
-    }
     operator const VkImageFormatProperties2KHR&() const
     {
       return *reinterpret_cast<const VkImageFormatProperties2KHR*>(this);
@@ -19797,10 +18989,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImageFormatProperties2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     ImageFormatProperties imageFormatProperties;
   };
   static_assert( sizeof( ImageFormatProperties2KHR ) == sizeof( VkImageFormatProperties2KHR ), "struct and wrapper have different size!" );
@@ -19808,9 +19000,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceSparseImageFormatInfo2KHR
   {
     PhysicalDeviceSparseImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageUsageFlags usage_ = ImageUsageFlags(), ImageTiling tiling_ = ImageTiling::eOptimal )
-      : sType( StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR )
-      , pNext( nullptr )
-      , format( format_ )
+      : format( format_ )
       , type( type_ )
       , samples( samples_ )
       , usage( usage_ )
@@ -19886,10 +19076,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Format format;
     ImageType type;
     SampleCountFlagBits samples;
@@ -19901,9 +19091,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SampleLocationsInfoEXT
   {
     SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, Extent2D sampleLocationGridSize_ = Extent2D(), uint32_t sampleLocationsCount_ = 0, const SampleLocationEXT* pSampleLocations_ = nullptr )
-      : sType( StructureType::eSampleLocationsInfoEXT )
-      , pNext( nullptr )
-      , sampleLocationsPerPixel( sampleLocationsPerPixel_ )
+      : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
       , sampleLocationGridSize( sampleLocationGridSize_ )
       , sampleLocationsCount( sampleLocationsCount_ )
       , pSampleLocations( pSampleLocations_ )
@@ -19971,10 +19159,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSampleLocationsInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SampleCountFlagBits sampleLocationsPerPixel;
     Extent2D sampleLocationGridSize;
     uint32_t sampleLocationsCount;
@@ -20087,9 +19275,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct RenderPassSampleLocationsBeginInfoEXT
   {
     RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, uint32_t postSubpassSampleLocationsCount_ = 0, const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
-      : sType( StructureType::eRenderPassSampleLocationsBeginInfoEXT )
-      , pNext( nullptr )
-      , attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
+      : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
       , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
       , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
       , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
@@ -20157,10 +19343,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t attachmentInitialSampleLocationsCount;
     const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
     uint32_t postSubpassSampleLocationsCount;
@@ -20171,9 +19357,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineSampleLocationsStateCreateInfoEXT
   {
     PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : sType( StructureType::ePipelineSampleLocationsStateCreateInfoEXT )
-      , pNext( nullptr )
-      , sampleLocationsEnable( sampleLocationsEnable_ )
+      : sampleLocationsEnable( sampleLocationsEnable_ )
       , sampleLocationsInfo( sampleLocationsInfo_ )
     {
     }
@@ -20225,10 +19409,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Bool32 sampleLocationsEnable;
     SampleLocationsInfoEXT sampleLocationsInfo;
   };
@@ -20236,22 +19420,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceSampleLocationsPropertiesEXT
   {
-    PhysicalDeviceSampleLocationsPropertiesEXT(  )
-      : sType( StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) );
-    }
-
-    PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceSampleLocationsPropertiesEXT&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
@@ -20274,10 +19442,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     SampleCountFlags sampleLocationSampleCounts;
     Extent2D maxSampleLocationGridSize;
     float sampleLocationCoordinateRange[2];
@@ -20480,9 +19648,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DescriptorPoolCreateInfo
   {
     DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr )
-      : sType( StructureType::eDescriptorPoolCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , maxSets( maxSets_ )
       , poolSizeCount( poolSizeCount_ )
       , pPoolSizes( pPoolSizes_ )
@@ -20550,10 +19716,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDescriptorPoolCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DescriptorPoolCreateFlags flags;
     uint32_t maxSets;
     uint32_t poolSizeCount;
@@ -20715,20 +19881,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SurfaceFormatKHR
   {
-    SurfaceFormatKHR(  )
-    {
-    }
-
-    SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceFormatKHR ) );
-    }
-
-    SurfaceFormatKHR& operator=( VkSurfaceFormatKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceFormatKHR ) );
-      return *this;
-    }
     operator const VkSurfaceFormatKHR&() const
     {
       return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
@@ -20752,22 +19904,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SurfaceFormat2KHR
   {
-    SurfaceFormat2KHR(  )
-      : sType( StructureType::eSurfaceFormat2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceFormat2KHR ) );
-    }
-
-    SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceFormat2KHR ) );
-      return *this;
-    }
     operator const VkSurfaceFormat2KHR&() const
     {
       return *reinterpret_cast<const VkSurfaceFormat2KHR*>(this);
@@ -20786,10 +19922,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSurfaceFormat2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     SurfaceFormatKHR surfaceFormat;
   };
   static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
@@ -20824,20 +19960,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct DisplayPlaneCapabilitiesKHR
   {
-    DisplayPlaneCapabilitiesKHR(  )
-    {
-    }
-
-    DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPlaneCapabilitiesKHR ) );
-    }
-
-    DisplayPlaneCapabilitiesKHR& operator=( VkDisplayPlaneCapabilitiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPlaneCapabilitiesKHR ) );
-      return *this;
-    }
     operator const VkDisplayPlaneCapabilitiesKHR&() const
     {
       return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
@@ -20936,20 +20058,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct DisplayPropertiesKHR
   {
-    DisplayPropertiesKHR(  )
-    {
-    }
-
-    DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPropertiesKHR ) );
-    }
-
-    DisplayPropertiesKHR& operator=( VkDisplayPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPropertiesKHR ) );
-      return *this;
-    }
     operator const VkDisplayPropertiesKHR&() const
     {
       return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
@@ -20984,9 +20092,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DisplaySurfaceCreateInfoKHR
   {
     DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), DisplayModeKHR displayMode_ = DisplayModeKHR(), uint32_t planeIndex_ = 0, uint32_t planeStackIndex_ = 0, SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, float globalAlpha_ = 0, DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, Extent2D imageExtent_ = Extent2D() )
-      : sType( StructureType::eDisplaySurfaceCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , displayMode( displayMode_ )
       , planeIndex( planeIndex_ )
       , planeStackIndex( planeStackIndex_ )
@@ -21086,10 +20192,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DisplaySurfaceCreateFlagsKHR flags;
     DisplayModeKHR displayMode;
     uint32_t planeIndex;
@@ -21103,20 +20209,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SurfaceCapabilitiesKHR
   {
-    SurfaceCapabilitiesKHR(  )
-    {
-    }
-
-    SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceCapabilitiesKHR ) );
-    }
-
-    SurfaceCapabilitiesKHR& operator=( VkSurfaceCapabilitiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceCapabilitiesKHR ) );
-      return *this;
-    }
     operator const VkSurfaceCapabilitiesKHR&() const
     {
       return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
@@ -21156,22 +20248,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SurfaceCapabilities2KHR
   {
-    SurfaceCapabilities2KHR(  )
-      : sType( StructureType::eSurfaceCapabilities2KHR )
-      , pNext( nullptr )
-    {
-    }
-
-    SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceCapabilities2KHR ) );
-    }
-
-    SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceCapabilities2KHR ) );
-      return *this;
-    }
     operator const VkSurfaceCapabilities2KHR&() const
     {
       return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(this);
@@ -21190,10 +20266,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSurfaceCapabilities2KHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     SurfaceCapabilitiesKHR surfaceCapabilities;
   };
   static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
@@ -21230,9 +20306,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DebugReportCallbackCreateInfoEXT
   {
     DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr )
-      : sType( StructureType::eDebugReportCallbackCreateInfoEXT )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , pfnCallback( pfnCallback_ )
       , pUserData( pUserData_ )
     {
@@ -21292,10 +20366,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DebugReportFlagsEXT flags;
     PFN_vkDebugReportCallbackEXT pfnCallback;
     void* pUserData;
@@ -21345,9 +20419,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DebugMarkerObjectNameInfoEXT
   {
     DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr )
-      : sType( StructureType::eDebugMarkerObjectNameInfoEXT )
-      , pNext( nullptr )
-      , objectType( objectType_ )
+      : objectType( objectType_ )
       , object( object_ )
       , pObjectName( pObjectName_ )
     {
@@ -21407,10 +20479,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DebugReportObjectTypeEXT objectType;
     uint64_t object;
     const char* pObjectName;
@@ -21420,9 +20492,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DebugMarkerObjectTagInfoEXT
   {
     DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr )
-      : sType( StructureType::eDebugMarkerObjectTagInfoEXT )
-      , pNext( nullptr )
-      , objectType( objectType_ )
+      : objectType( objectType_ )
       , object( object_ )
       , tagName( tagName_ )
       , tagSize( tagSize_ )
@@ -21498,10 +20568,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DebugReportObjectTypeEXT objectType;
     uint64_t object;
     uint64_t tagName;
@@ -21519,9 +20589,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineRasterizationStateRasterizationOrderAMD
   {
     PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
-      : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD )
-      , pNext( nullptr )
-      , rasterizationOrder( rasterizationOrder_ )
+      : rasterizationOrder( rasterizationOrder_ )
     {
     }
 
@@ -21565,10 +20633,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     RasterizationOrderAMD rasterizationOrder;
   };
   static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
@@ -21604,9 +20672,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExternalMemoryImageCreateInfoNV
   {
     ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
-      : sType( StructureType::eExternalMemoryImageCreateInfoNV )
-      , pNext( nullptr )
-      , handleTypes( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {
     }
 
@@ -21650,10 +20716,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagsNV handleTypes;
   };
   static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
@@ -21661,9 +20727,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExportMemoryAllocateInfoNV
   {
     ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
-      : sType( StructureType::eExportMemoryAllocateInfoNV )
-      , pNext( nullptr )
-      , handleTypes( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {
     }
 
@@ -21707,10 +20771,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagsNV handleTypes;
   };
   static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
@@ -21719,9 +20783,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImportMemoryWin32HandleInfoNV
   {
     ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 )
-      : sType( StructureType::eImportMemoryWin32HandleInfoNV )
-      , pNext( nullptr )
-      , handleType( handleType_ )
+      : handleType( handleType_ )
       , handle( handle_ )
     {
     }
@@ -21773,10 +20835,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagsNV handleType;
     HANDLE handle;
   };
@@ -21812,20 +20874,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExternalImageFormatPropertiesNV
   {
-    ExternalImageFormatPropertiesNV(  )
-    {
-    }
-
-    ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalImageFormatPropertiesNV ) );
-    }
-
-    ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalImageFormatPropertiesNV ) );
-      return *this;
-    }
     operator const VkExternalImageFormatPropertiesNV&() const
     {
       return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
@@ -21860,9 +20908,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ValidationFlagsEXT
   {
     ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
-      : sType( StructureType::eValidationFlagsEXT )
-      , pNext( nullptr )
-      , disabledValidationCheckCount( disabledValidationCheckCount_ )
+      : disabledValidationCheckCount( disabledValidationCheckCount_ )
       , pDisabledValidationChecks( pDisabledValidationChecks_ )
     {
     }
@@ -21914,10 +20960,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eValidationFlagsEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t disabledValidationCheckCount;
     ValidationCheckEXT* pDisabledValidationChecks;
   };
@@ -22121,9 +21167,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct IndirectCommandsLayoutCreateInfoNVX
   {
     IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
-      : sType( StructureType::eIndirectCommandsLayoutCreateInfoNVX )
-      , pNext( nullptr )
-      , pipelineBindPoint( pipelineBindPoint_ )
+      : pipelineBindPoint( pipelineBindPoint_ )
       , flags( flags_ )
       , tokenCount( tokenCount_ )
       , pTokens( pTokens_ )
@@ -22191,10 +21235,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineBindPoint pipelineBindPoint;
     IndirectCommandsLayoutUsageFlagsNVX flags;
     uint32_t tokenCount;
@@ -22214,9 +21258,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ObjectTableCreateInfoNVX
   {
     ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, const uint32_t* pObjectEntryCounts_ = nullptr, const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, uint32_t maxUniformBuffersPerDescriptor_ = 0, uint32_t maxStorageBuffersPerDescriptor_ = 0, uint32_t maxStorageImagesPerDescriptor_ = 0, uint32_t maxSampledImagesPerDescriptor_ = 0, uint32_t maxPipelineLayouts_ = 0 )
-      : sType( StructureType::eObjectTableCreateInfoNVX )
-      , pNext( nullptr )
-      , objectCount( objectCount_ )
+      : objectCount( objectCount_ )
       , pObjectEntryTypes( pObjectEntryTypes_ )
       , pObjectEntryCounts( pObjectEntryCounts_ )
       , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
@@ -22324,10 +21366,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eObjectTableCreateInfoNVX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t objectCount;
     const ObjectEntryTypeNVX* pObjectEntryTypes;
     const uint32_t* pObjectEntryCounts;
@@ -22746,9 +21788,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DescriptorSetLayoutCreateInfo
   {
     DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr )
-      : sType( StructureType::eDescriptorSetLayoutCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , bindingCount( bindingCount_ )
       , pBindings( pBindings_ )
     {
@@ -22808,10 +21848,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DescriptorSetLayoutCreateFlags flags;
     uint32_t bindingCount;
     const DescriptorSetLayoutBinding* pBindings;
@@ -22855,9 +21895,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceExternalImageFormatInfoKHR
   {
     PhysicalDeviceExternalImageFormatInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::ePhysicalDeviceExternalImageFormatInfoKHR )
-      , pNext( nullptr )
-      , handleType( handleType_ )
+      : handleType( handleType_ )
     {
     }
 
@@ -22901,10 +21939,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagBitsKHR handleType;
   };
   static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHR ), "struct and wrapper have different size!" );
@@ -22912,9 +21950,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceExternalBufferInfoKHR
   {
     PhysicalDeviceExternalBufferInfoKHR( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::ePhysicalDeviceExternalBufferInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , usage( usage_ )
       , handleType( handleType_ )
     {
@@ -22974,10 +22010,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     BufferCreateFlags flags;
     BufferUsageFlags usage;
     ExternalMemoryHandleTypeFlagBitsKHR handleType;
@@ -22987,9 +22023,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExternalMemoryImageCreateInfoKHR
   {
     ExternalMemoryImageCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
-      : sType( StructureType::eExternalMemoryImageCreateInfoKHR )
-      , pNext( nullptr )
-      , handleTypes( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {
     }
 
@@ -23033,10 +22067,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExternalMemoryImageCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagsKHR handleTypes;
   };
   static_assert( sizeof( ExternalMemoryImageCreateInfoKHR ) == sizeof( VkExternalMemoryImageCreateInfoKHR ), "struct and wrapper have different size!" );
@@ -23044,9 +22078,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExternalMemoryBufferCreateInfoKHR
   {
     ExternalMemoryBufferCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
-      : sType( StructureType::eExternalMemoryBufferCreateInfoKHR )
-      , pNext( nullptr )
-      , handleTypes( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {
     }
 
@@ -23090,10 +22122,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExternalMemoryBufferCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagsKHR handleTypes;
   };
   static_assert( sizeof( ExternalMemoryBufferCreateInfoKHR ) == sizeof( VkExternalMemoryBufferCreateInfoKHR ), "struct and wrapper have different size!" );
@@ -23101,9 +22133,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExportMemoryAllocateInfoKHR
   {
     ExportMemoryAllocateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
-      : sType( StructureType::eExportMemoryAllocateInfoKHR )
-      , pNext( nullptr )
-      , handleTypes( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {
     }
 
@@ -23147,10 +22177,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExportMemoryAllocateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagsKHR handleTypes;
   };
   static_assert( sizeof( ExportMemoryAllocateInfoKHR ) == sizeof( VkExportMemoryAllocateInfoKHR ), "struct and wrapper have different size!" );
@@ -23159,9 +22189,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImportMemoryWin32HandleInfoKHR
   {
     ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
-      : sType( StructureType::eImportMemoryWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , handleType( handleType_ )
+      : handleType( handleType_ )
       , handle( handle_ )
       , name( name_ )
     {
@@ -23221,10 +22249,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagBitsKHR handleType;
     HANDLE handle;
     LPCWSTR name;
@@ -23236,9 +22264,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MemoryGetWin32HandleInfoKHR
   {
     MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::eMemoryGetWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , memory( memory_ )
+      : memory( memory_ )
       , handleType( handleType_ )
     {
     }
@@ -23290,10 +22316,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DeviceMemory memory;
     ExternalMemoryHandleTypeFlagBitsKHR handleType;
   };
@@ -23303,9 +22329,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImportMemoryFdInfoKHR
   {
     ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
-      : sType( StructureType::eImportMemoryFdInfoKHR )
-      , pNext( nullptr )
-      , handleType( handleType_ )
+      : handleType( handleType_ )
       , fd( fd_ )
     {
     }
@@ -23357,10 +22381,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImportMemoryFdInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagBitsKHR handleType;
     int fd;
   };
@@ -23369,9 +22393,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MemoryGetFdInfoKHR
   {
     MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::eMemoryGetFdInfoKHR )
-      , pNext( nullptr )
-      , memory( memory_ )
+      : memory( memory_ )
       , handleType( handleType_ )
     {
     }
@@ -23423,10 +22445,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryGetFdInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DeviceMemory memory;
     ExternalMemoryHandleTypeFlagBitsKHR handleType;
   };
@@ -23435,9 +22457,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImportMemoryHostPointerInfoEXT
   {
     ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, void* pHostPointer_ = nullptr )
-      : sType( StructureType::eImportMemoryHostPointerInfoEXT )
-      , pNext( nullptr )
-      , handleType( handleType_ )
+      : handleType( handleType_ )
       , pHostPointer( pHostPointer_ )
     {
     }
@@ -23489,10 +22509,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalMemoryHandleTypeFlagBitsKHR handleType;
     void* pHostPointer;
   };
@@ -23527,20 +22547,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExternalMemoryPropertiesKHR
   {
-    ExternalMemoryPropertiesKHR(  )
-    {
-    }
-
-    ExternalMemoryPropertiesKHR( VkExternalMemoryPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryPropertiesKHR ) );
-    }
-
-    ExternalMemoryPropertiesKHR& operator=( VkExternalMemoryPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryPropertiesKHR ) );
-      return *this;
-    }
     operator const VkExternalMemoryPropertiesKHR&() const
     {
       return *reinterpret_cast<const VkExternalMemoryPropertiesKHR*>(this);
@@ -23566,22 +22572,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExternalImageFormatPropertiesKHR
   {
-    ExternalImageFormatPropertiesKHR(  )
-      : sType( StructureType::eExternalImageFormatPropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    ExternalImageFormatPropertiesKHR( VkExternalImageFormatPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalImageFormatPropertiesKHR ) );
-    }
-
-    ExternalImageFormatPropertiesKHR& operator=( VkExternalImageFormatPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalImageFormatPropertiesKHR ) );
-      return *this;
-    }
     operator const VkExternalImageFormatPropertiesKHR&() const
     {
       return *reinterpret_cast<const VkExternalImageFormatPropertiesKHR*>(this);
@@ -23600,32 +22590,16 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExternalImageFormatPropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     ExternalMemoryPropertiesKHR externalMemoryProperties;
   };
   static_assert( sizeof( ExternalImageFormatPropertiesKHR ) == sizeof( VkExternalImageFormatPropertiesKHR ), "struct and wrapper have different size!" );
 
   struct ExternalBufferPropertiesKHR
   {
-    ExternalBufferPropertiesKHR(  )
-      : sType( StructureType::eExternalBufferPropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    ExternalBufferPropertiesKHR( VkExternalBufferPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalBufferPropertiesKHR ) );
-    }
-
-    ExternalBufferPropertiesKHR& operator=( VkExternalBufferPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalBufferPropertiesKHR ) );
-      return *this;
-    }
     operator const VkExternalBufferPropertiesKHR&() const
     {
       return *reinterpret_cast<const VkExternalBufferPropertiesKHR*>(this);
@@ -23644,10 +22618,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExternalBufferPropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     ExternalMemoryPropertiesKHR externalMemoryProperties;
   };
   static_assert( sizeof( ExternalBufferPropertiesKHR ) == sizeof( VkExternalBufferPropertiesKHR ), "struct and wrapper have different size!" );
@@ -23684,9 +22658,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceExternalSemaphoreInfoKHR
   {
     PhysicalDeviceExternalSemaphoreInfoKHR( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR )
-      , pNext( nullptr )
-      , handleType( handleType_ )
+      : handleType( handleType_ )
     {
     }
 
@@ -23730,10 +22702,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
   };
   static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHR ), "struct and wrapper have different size!" );
@@ -23741,9 +22713,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExportSemaphoreCreateInfoKHR
   {
     ExportSemaphoreCreateInfoKHR( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHR() )
-      : sType( StructureType::eExportSemaphoreCreateInfoKHR )
-      , pNext( nullptr )
-      , handleTypes( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {
     }
 
@@ -23787,10 +22757,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExportSemaphoreCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalSemaphoreHandleTypeFlagsKHR handleTypes;
   };
   static_assert( sizeof( ExportSemaphoreCreateInfoKHR ) == sizeof( VkExportSemaphoreCreateInfoKHR ), "struct and wrapper have different size!" );
@@ -23799,9 +22769,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SemaphoreGetWin32HandleInfoKHR
   {
     SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::eSemaphoreGetWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , semaphore( semaphore_ )
+      : semaphore( semaphore_ )
       , handleType( handleType_ )
     {
     }
@@ -23853,10 +22821,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Semaphore semaphore;
     ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
   };
@@ -23866,9 +22834,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SemaphoreGetFdInfoKHR
   {
     SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::eSemaphoreGetFdInfoKHR )
-      , pNext( nullptr )
-      , semaphore( semaphore_ )
+      : semaphore( semaphore_ )
       , handleType( handleType_ )
     {
     }
@@ -23920,10 +22886,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Semaphore semaphore;
     ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
   };
@@ -23957,22 +22923,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExternalSemaphorePropertiesKHR
   {
-    ExternalSemaphorePropertiesKHR(  )
-      : sType( StructureType::eExternalSemaphorePropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    ExternalSemaphorePropertiesKHR( VkExternalSemaphorePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalSemaphorePropertiesKHR ) );
-    }
-
-    ExternalSemaphorePropertiesKHR& operator=( VkExternalSemaphorePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalSemaphorePropertiesKHR ) );
-      return *this;
-    }
     operator const VkExternalSemaphorePropertiesKHR&() const
     {
       return *reinterpret_cast<const VkExternalSemaphorePropertiesKHR*>(this);
@@ -23993,10 +22943,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExternalSemaphorePropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     ExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes;
     ExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes;
     ExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures;
@@ -24032,9 +22982,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImportSemaphoreWin32HandleInfoKHR
   {
     ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
-      : sType( StructureType::eImportSemaphoreWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , semaphore( semaphore_ )
+      : semaphore( semaphore_ )
       , flags( flags_ )
       , handleType( handleType_ )
       , handle( handle_ )
@@ -24110,10 +23058,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Semaphore semaphore;
     SemaphoreImportFlagsKHR flags;
     ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
@@ -24126,9 +23074,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImportSemaphoreFdInfoKHR
   {
     ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
-      : sType( StructureType::eImportSemaphoreFdInfoKHR )
-      , pNext( nullptr )
-      , semaphore( semaphore_ )
+      : semaphore( semaphore_ )
       , flags( flags_ )
       , handleType( handleType_ )
       , fd( fd_ )
@@ -24196,10 +23142,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Semaphore semaphore;
     SemaphoreImportFlagsKHR flags;
     ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
@@ -24238,9 +23184,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceExternalFenceInfoKHR
   {
     PhysicalDeviceExternalFenceInfoKHR( ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::ePhysicalDeviceExternalFenceInfoKHR )
-      , pNext( nullptr )
-      , handleType( handleType_ )
+      : handleType( handleType_ )
     {
     }
 
@@ -24284,10 +23228,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalFenceHandleTypeFlagBitsKHR handleType;
   };
   static_assert( sizeof( PhysicalDeviceExternalFenceInfoKHR ) == sizeof( VkPhysicalDeviceExternalFenceInfoKHR ), "struct and wrapper have different size!" );
@@ -24295,9 +23239,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ExportFenceCreateInfoKHR
   {
     ExportFenceCreateInfoKHR( ExternalFenceHandleTypeFlagsKHR handleTypes_ = ExternalFenceHandleTypeFlagsKHR() )
-      : sType( StructureType::eExportFenceCreateInfoKHR )
-      , pNext( nullptr )
-      , handleTypes( handleTypes_ )
+      : handleTypes( handleTypes_ )
     {
     }
 
@@ -24341,10 +23283,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExportFenceCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ExternalFenceHandleTypeFlagsKHR handleTypes;
   };
   static_assert( sizeof( ExportFenceCreateInfoKHR ) == sizeof( VkExportFenceCreateInfoKHR ), "struct and wrapper have different size!" );
@@ -24353,9 +23295,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct FenceGetWin32HandleInfoKHR
   {
     FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::eFenceGetWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , fence( fence_ )
+      : fence( fence_ )
       , handleType( handleType_ )
     {
     }
@@ -24407,10 +23347,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Fence fence;
     ExternalFenceHandleTypeFlagBitsKHR handleType;
   };
@@ -24420,9 +23360,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct FenceGetFdInfoKHR
   {
     FenceGetFdInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
-      : sType( StructureType::eFenceGetFdInfoKHR )
-      , pNext( nullptr )
-      , fence( fence_ )
+      : fence( fence_ )
       , handleType( handleType_ )
     {
     }
@@ -24474,10 +23412,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eFenceGetFdInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Fence fence;
     ExternalFenceHandleTypeFlagBitsKHR handleType;
   };
@@ -24511,22 +23449,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct ExternalFencePropertiesKHR
   {
-    ExternalFencePropertiesKHR(  )
-      : sType( StructureType::eExternalFencePropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    ExternalFencePropertiesKHR( VkExternalFencePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalFencePropertiesKHR ) );
-    }
-
-    ExternalFencePropertiesKHR& operator=( VkExternalFencePropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalFencePropertiesKHR ) );
-      return *this;
-    }
     operator const VkExternalFencePropertiesKHR&() const
     {
       return *reinterpret_cast<const VkExternalFencePropertiesKHR*>(this);
@@ -24547,10 +23469,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eExternalFencePropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     ExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes;
     ExternalFenceHandleTypeFlagsKHR compatibleHandleTypes;
     ExternalFenceFeatureFlagsKHR externalFenceFeatures;
@@ -24586,9 +23508,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImportFenceWin32HandleInfoKHR
   {
     ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
-      : sType( StructureType::eImportFenceWin32HandleInfoKHR )
-      , pNext( nullptr )
-      , fence( fence_ )
+      : fence( fence_ )
       , flags( flags_ )
       , handleType( handleType_ )
       , handle( handle_ )
@@ -24664,10 +23584,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Fence fence;
     FenceImportFlagsKHR flags;
     ExternalFenceHandleTypeFlagBitsKHR handleType;
@@ -24680,9 +23600,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImportFenceFdInfoKHR
   {
     ImportFenceFdInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
-      : sType( StructureType::eImportFenceFdInfoKHR )
-      , pNext( nullptr )
-      , fence( fence_ )
+      : fence( fence_ )
       , flags( flags_ )
       , handleType( handleType_ )
       , fd( fd_ )
@@ -24750,10 +23668,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eImportFenceFdInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Fence fence;
     FenceImportFlagsKHR flags;
     ExternalFenceHandleTypeFlagBitsKHR handleType;
@@ -24788,22 +23706,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SurfaceCapabilities2EXT
   {
-    SurfaceCapabilities2EXT(  )
-      : sType( StructureType::eSurfaceCapabilities2EXT )
-      , pNext( nullptr )
-    {
-    }
-
-    SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceCapabilities2EXT ) );
-    }
-
-    SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SurfaceCapabilities2EXT ) );
-      return *this;
-    }
     operator const VkSurfaceCapabilities2EXT&() const
     {
       return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
@@ -24832,10 +23734,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSurfaceCapabilities2EXT;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t minImageCount;
     uint32_t maxImageCount;
     Extent2D currentExtent;
@@ -24853,9 +23755,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SwapchainCounterCreateInfoEXT
   {
     SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
-      : sType( StructureType::eSwapchainCounterCreateInfoEXT )
-      , pNext( nullptr )
-      , surfaceCounters( surfaceCounters_ )
+      : surfaceCounters( surfaceCounters_ )
     {
     }
 
@@ -24899,10 +23799,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SurfaceCounterFlagsEXT surfaceCounters;
   };
   static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
@@ -24917,9 +23817,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DisplayPowerInfoEXT
   {
     DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
-      : sType( StructureType::eDisplayPowerInfoEXT )
-      , pNext( nullptr )
-      , powerState( powerState_ )
+      : powerState( powerState_ )
     {
     }
 
@@ -24963,10 +23861,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDisplayPowerInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DisplayPowerStateEXT powerState;
   };
   static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
@@ -24979,9 +23877,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceEventInfoEXT
   {
     DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
-      : sType( StructureType::eDeviceEventInfoEXT )
-      , pNext( nullptr )
-      , deviceEvent( deviceEvent_ )
+      : deviceEvent( deviceEvent_ )
     {
     }
 
@@ -25025,10 +23921,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceEventInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DeviceEventTypeEXT deviceEvent;
   };
   static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
@@ -25041,9 +23937,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DisplayEventInfoEXT
   {
     DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
-      : sType( StructureType::eDisplayEventInfoEXT )
-      , pNext( nullptr )
-      , displayEvent( displayEvent_ )
+      : displayEvent( displayEvent_ )
     {
     }
 
@@ -25087,10 +23981,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDisplayEventInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DisplayEventTypeEXT displayEvent;
   };
   static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
@@ -25151,9 +24045,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct MemoryAllocateFlagsInfoKHX
   {
     MemoryAllocateFlagsInfoKHX( MemoryAllocateFlagsKHX flags_ = MemoryAllocateFlagsKHX(), uint32_t deviceMask_ = 0 )
-      : sType( StructureType::eMemoryAllocateFlagsInfoKHX )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , deviceMask( deviceMask_ )
     {
     }
@@ -25205,10 +24097,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eMemoryAllocateFlagsInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     MemoryAllocateFlagsKHX flags;
     uint32_t deviceMask;
   };
@@ -25244,22 +24136,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct DeviceGroupPresentCapabilitiesKHX
   {
-    DeviceGroupPresentCapabilitiesKHX(  )
-      : sType( StructureType::eDeviceGroupPresentCapabilitiesKHX )
-      , pNext( nullptr )
-    {
-    }
-
-    DeviceGroupPresentCapabilitiesKHX( VkDeviceGroupPresentCapabilitiesKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupPresentCapabilitiesKHX ) );
-    }
-
-    DeviceGroupPresentCapabilitiesKHX& operator=( VkDeviceGroupPresentCapabilitiesKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupPresentCapabilitiesKHX ) );
-      return *this;
-    }
     operator const VkDeviceGroupPresentCapabilitiesKHX&() const
     {
       return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHX*>(this);
@@ -25279,10 +24155,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
     DeviceGroupPresentModeFlagsKHX modes;
   };
@@ -25291,9 +24167,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGroupPresentInfoKHX
   {
     DeviceGroupPresentInfoKHX( uint32_t swapchainCount_ = 0, const uint32_t* pDeviceMasks_ = nullptr, DeviceGroupPresentModeFlagBitsKHX mode_ = DeviceGroupPresentModeFlagBitsKHX::eLocal )
-      : sType( StructureType::eDeviceGroupPresentInfoKHX )
-      , pNext( nullptr )
-      , swapchainCount( swapchainCount_ )
+      : swapchainCount( swapchainCount_ )
       , pDeviceMasks( pDeviceMasks_ )
       , mode( mode_ )
     {
@@ -25353,10 +24227,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGroupPresentInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t swapchainCount;
     const uint32_t* pDeviceMasks;
     DeviceGroupPresentModeFlagBitsKHX mode;
@@ -25366,9 +24240,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGroupSwapchainCreateInfoKHX
   {
     DeviceGroupSwapchainCreateInfoKHX( DeviceGroupPresentModeFlagsKHX modes_ = DeviceGroupPresentModeFlagsKHX() )
-      : sType( StructureType::eDeviceGroupSwapchainCreateInfoKHX )
-      , pNext( nullptr )
-      , modes( modes_ )
+      : modes( modes_ )
     {
     }
 
@@ -25412,10 +24284,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     DeviceGroupPresentModeFlagsKHX modes;
   };
   static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHX ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHX ), "struct and wrapper have different size!" );
@@ -25448,9 +24320,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SwapchainCreateInfoKHR
   {
     SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(), SurfaceKHR surface_ = SurfaceKHR(), uint32_t minImageCount_ = 0, Format imageFormat_ = Format::eUndefined, ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, Extent2D imageExtent_ = Extent2D(), uint32_t imageArrayLayers_ = 0, ImageUsageFlags imageUsage_ = ImageUsageFlags(), SharingMode imageSharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, Bool32 clipped_ = 0, SwapchainKHR oldSwapchain_ = SwapchainKHR() )
-      : sType( StructureType::eSwapchainCreateInfoKHR )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , surface( surface_ )
       , minImageCount( minImageCount_ )
       , imageFormat( imageFormat_ )
@@ -25614,10 +24484,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSwapchainCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SwapchainCreateFlagsKHR flags;
     SurfaceKHR surface;
     uint32_t minImageCount;
@@ -25721,9 +24591,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineViewportSwizzleStateCreateInfoNV
   {
     PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_ = 0, const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
-      : sType( StructureType::ePipelineViewportSwizzleStateCreateInfoNV )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , viewportCount( viewportCount_ )
       , pViewportSwizzles( pViewportSwizzles_ )
     {
@@ -25783,10 +24651,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineViewportSwizzleStateCreateFlagsNV flags;
     uint32_t viewportCount;
     const ViewportSwizzleNV* pViewportSwizzles;
@@ -25802,9 +24670,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineDiscardRectangleStateCreateInfoEXT
   {
     PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = 0, const Rect2D* pDiscardRectangles_ = nullptr )
-      : sType( StructureType::ePipelineDiscardRectangleStateCreateInfoEXT )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , discardRectangleMode( discardRectangleMode_ )
       , discardRectangleCount( discardRectangleCount_ )
       , pDiscardRectangles( pDiscardRectangles_ )
@@ -25872,10 +24738,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineDiscardRectangleStateCreateFlagsEXT flags;
     DiscardRectangleModeEXT discardRectangleMode;
     uint32_t discardRectangleCount;
@@ -26035,9 +24901,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct RenderPassCreateInfo
   {
     RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, const AttachmentDescription* pAttachments_ = nullptr, uint32_t subpassCount_ = 0, const SubpassDescription* pSubpasses_ = nullptr, uint32_t dependencyCount_ = 0, const SubpassDependency* pDependencies_ = nullptr )
-      : sType( StructureType::eRenderPassCreateInfo )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , attachmentCount( attachmentCount_ )
       , pAttachments( pAttachments_ )
       , subpassCount( subpassCount_ )
@@ -26129,10 +24993,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eRenderPassCreateInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     RenderPassCreateFlags flags;
     uint32_t attachmentCount;
     const AttachmentDescription* pAttachments;
@@ -26151,22 +25015,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDevicePointClippingPropertiesKHR
   {
-    PhysicalDevicePointClippingPropertiesKHR(  )
-      : sType( StructureType::ePhysicalDevicePointClippingPropertiesKHR )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDevicePointClippingPropertiesKHR( VkPhysicalDevicePointClippingPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevicePointClippingPropertiesKHR ) );
-    }
-
-    PhysicalDevicePointClippingPropertiesKHR& operator=( VkPhysicalDevicePointClippingPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevicePointClippingPropertiesKHR ) );
-      return *this;
-    }
     operator const VkPhysicalDevicePointClippingPropertiesKHR&() const
     {
       return *reinterpret_cast<const VkPhysicalDevicePointClippingPropertiesKHR*>(this);
@@ -26185,10 +25033,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDevicePointClippingPropertiesKHR;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     PointClippingBehaviorKHR pointClippingBehavior;
   };
   static_assert( sizeof( PhysicalDevicePointClippingPropertiesKHR ) == sizeof( VkPhysicalDevicePointClippingPropertiesKHR ), "struct and wrapper have different size!" );
@@ -26203,9 +25051,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SamplerReductionModeCreateInfoEXT
   {
     SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage )
-      : sType( StructureType::eSamplerReductionModeCreateInfoEXT )
-      , pNext( nullptr )
-      , reductionMode( reductionMode_ )
+      : reductionMode( reductionMode_ )
     {
     }
 
@@ -26249,10 +25095,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     SamplerReductionModeEXT reductionMode;
   };
   static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
@@ -26266,9 +25112,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineTessellationDomainOriginStateCreateInfoKHR
   {
     PipelineTessellationDomainOriginStateCreateInfoKHR( TessellationDomainOriginKHR domainOrigin_ = TessellationDomainOriginKHR::eUpperLeft )
-      : sType( StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR )
-      , pNext( nullptr )
-      , domainOrigin( domainOrigin_ )
+      : domainOrigin( domainOrigin_ )
     {
     }
 
@@ -26312,10 +25156,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     TessellationDomainOriginKHR domainOrigin;
   };
   static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfoKHR ), "struct and wrapper have different size!" );
@@ -26344,9 +25188,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SamplerYcbcrConversionCreateInfoKHR
   {
     SamplerYcbcrConversionCreateInfoKHR( Format format_ = Format::eUndefined, SamplerYcbcrModelConversionKHR ycbcrModel_ = SamplerYcbcrModelConversionKHR::eRgbIdentity, SamplerYcbcrRangeKHR ycbcrRange_ = SamplerYcbcrRangeKHR::eItuFull, ComponentMapping components_ = ComponentMapping(), ChromaLocationKHR xChromaOffset_ = ChromaLocationKHR::eCositedEven, ChromaLocationKHR yChromaOffset_ = ChromaLocationKHR::eCositedEven, Filter chromaFilter_ = Filter::eNearest, Bool32 forceExplicitReconstruction_ = 0 )
-      : sType( StructureType::eSamplerYcbcrConversionCreateInfoKHR )
-      , pNext( nullptr )
-      , format( format_ )
+      : format( format_ )
       , ycbcrModel( ycbcrModel_ )
       , ycbcrRange( ycbcrRange_ )
       , components( components_ )
@@ -26446,10 +25288,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfoKHR;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Format format;
     SamplerYcbcrModelConversionKHR ycbcrModel;
     SamplerYcbcrRangeKHR ycbcrRange;
@@ -26471,9 +25313,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineColorBlendAdvancedStateCreateInfoEXT
   {
     PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0, Bool32 dstPremultiplied_ = 0, BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
-      : sType( StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT )
-      , pNext( nullptr )
-      , srcPremultiplied( srcPremultiplied_ )
+      : srcPremultiplied( srcPremultiplied_ )
       , dstPremultiplied( dstPremultiplied_ )
       , blendOverlap( blendOverlap_ )
     {
@@ -26533,10 +25373,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     Bool32 srcPremultiplied;
     Bool32 dstPremultiplied;
     BlendOverlapEXT blendOverlap;
@@ -26554,9 +25394,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PipelineCoverageModulationStateCreateInfoNV
   {
     PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(), CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, Bool32 coverageModulationTableEnable_ = 0, uint32_t coverageModulationTableCount_ = 0, const float* pCoverageModulationTable_ = nullptr )
-      : sType( StructureType::ePipelineCoverageModulationStateCreateInfoNV )
-      , pNext( nullptr )
-      , flags( flags_ )
+      : flags( flags_ )
       , coverageModulationMode( coverageModulationMode_ )
       , coverageModulationTableEnable( coverageModulationTableEnable_ )
       , coverageModulationTableCount( coverageModulationTableCount_ )
@@ -26632,10 +25470,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     PipelineCoverageModulationStateCreateFlagsNV flags;
     CoverageModulationModeNV coverageModulationMode;
     Bool32 coverageModulationTableEnable;
@@ -26667,9 +25505,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceQueueGlobalPriorityCreateInfoEXT
   {
     DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
-      : sType( StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT )
-      , pNext( nullptr )
-      , globalPriority( globalPriority_ )
+      : globalPriority( globalPriority_ )
     {
     }
 
@@ -26713,10 +25549,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     QueueGlobalPriorityEXT globalPriority;
   };
   static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
@@ -27576,9 +26412,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct SubmitInfo
   {
     SubmitInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, const PipelineStageFlags* pWaitDstStageMask_ = nullptr, uint32_t commandBufferCount_ = 0, const CommandBuffer* pCommandBuffers_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr )
-      : sType( StructureType::eSubmitInfo )
-      , pNext( nullptr )
-      , waitSemaphoreCount( waitSemaphoreCount_ )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
       , pWaitSemaphores( pWaitSemaphores_ )
       , pWaitDstStageMask( pWaitDstStageMask_ )
       , commandBufferCount( commandBufferCount_ )
@@ -27670,10 +26504,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eSubmitInfo;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t waitSemaphoreCount;
     const Semaphore* pWaitSemaphores;
     const PipelineStageFlags* pWaitDstStageMask;
@@ -32385,9 +31219,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct CmdProcessCommandsInfoNVX
   {
     CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t indirectCommandsTokenCount_ = 0, const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, uint32_t maxSequencesCount_ = 0, CommandBuffer targetCommandBuffer_ = CommandBuffer(), Buffer sequencesCountBuffer_ = Buffer(), DeviceSize sequencesCountOffset_ = 0, Buffer sequencesIndexBuffer_ = Buffer(), DeviceSize sequencesIndexOffset_ = 0 )
-      : sType( StructureType::eCmdProcessCommandsInfoNVX )
-      , pNext( nullptr )
-      , objectTable( objectTable_ )
+      : objectTable( objectTable_ )
       , indirectCommandsLayout( indirectCommandsLayout_ )
       , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
       , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
@@ -32503,10 +31335,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     ObjectTableNVX objectTable;
     IndirectCommandsLayoutNVX indirectCommandsLayout;
     uint32_t indirectCommandsTokenCount;
@@ -32522,22 +31354,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct PhysicalDeviceGroupPropertiesKHX
   {
-    PhysicalDeviceGroupPropertiesKHX(  )
-      : sType( StructureType::ePhysicalDeviceGroupPropertiesKHX )
-      , pNext( nullptr )
-    {
-    }
-
-    PhysicalDeviceGroupPropertiesKHX( VkPhysicalDeviceGroupPropertiesKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceGroupPropertiesKHX ) );
-    }
-
-    PhysicalDeviceGroupPropertiesKHX& operator=( VkPhysicalDeviceGroupPropertiesKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceGroupPropertiesKHX ) );
-      return *this;
-    }
     operator const VkPhysicalDeviceGroupPropertiesKHX&() const
     {
       return *reinterpret_cast<const VkPhysicalDeviceGroupPropertiesKHX*>(this);
@@ -32558,10 +31374,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::ePhysicalDeviceGroupPropertiesKHX;
 
   public:
-    void* pNext;
+    void* pNext = nullptr;
     uint32_t physicalDeviceCount;
     PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
     Bool32 subsetAllocation;
@@ -33189,9 +32005,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceGroupDeviceCreateInfoKHX
   {
     DeviceGroupDeviceCreateInfoKHX( uint32_t physicalDeviceCount_ = 0, const PhysicalDevice* pPhysicalDevices_ = nullptr )
-      : sType( StructureType::eDeviceGroupDeviceCreateInfoKHX )
-      , pNext( nullptr )
-      , physicalDeviceCount( physicalDeviceCount_ )
+      : physicalDeviceCount( physicalDeviceCount_ )
       , pPhysicalDevices( pPhysicalDevices_ )
     {
     }
@@ -33243,10 +32057,10 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    StructureType sType;
+    StructureType sType = StructureType::eDeviceGroupDeviceCreateInfoKHX;
 
   public:
-    const void* pNext;
+    const void* pNext = nullptr;
     uint32_t physicalDeviceCount;
     const PhysicalDevice* pPhysicalDevices;
   };